Kirjoittaja Aihe: Skriptiajuri  (Luettu 55599 kertaa)

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Skriptiajuri
« : 01.01.11 - klo:23.41 »
Skriptiajuri on tarkoitettu skriptien tekemiseen ja tehdyistä huolehtimiseen. Skriptiajuri on silkkaa versionhallintaa: kaikki skripti-versiot, kaikki skriptien dokumentti-versiot ja skriptien kaikki tulosteet talletetaan ja ylläpidetään niistä ristiinviittauksia.

Skriptien nimillä ei ole muotovaatimuksia vaan kaikkea voi käyttää mitä näppäimistä irti saa - merkki / on kylläkin ongelmallinen sillä bash tajuaa sen tiedostonimeksi. Skriptejä ylläpidetään koti-kansion kansiossa nimeltään OMATSKRIPTIT.

Skriptiajuria on helpointa ajaa omalta kovalevyltä kun sille on ensin bootattu. Ajamiseen voi käyttää Skriptiajurille tehtyä käynnistintä joka on paras sijoittaa työpöydälle ja vielä parempi on ctrl-raahata se käynnistyspalkkiin. Skriptiajuria voi ajaa myös päätteessä käskyllä: . ~/OMATSKRIPTIT/Skriptiajuri. Skriptiajuria voi ajaa myös nautiluksella mistä hyvänsä. Yksi tapas on bootata live-CD:llä ja ajaa live-CD:n nautiluksella Skriptiajuria siitä koneesta johon on bootattu tai sitten USB-muistitikulta. Ja skriptiajurilla taas voi ajaa MidnightCommanderia jolloin on pääsy lähes kaikkialle mikä on liitetty siihen koneeseen jolta on bootattu.

Skriptiajurin paras ominaisuus on se ettei mitään tekemistään tarvitse harkita eikä mitään tarvitse muistaa, sillä pahin seuraus paniikki-kohelluksestakin on se että äskettäin tekemänsä joutuu tekemään osittain uudelleen. Sillä teetpä mitä hyvänsä: painat ctrl-c vahingossa tai tahallasi, boottaat, potkit konettasi ympäri kämppää ... niin aloitettaessa skriptiajuri uudelleen se aloittaa siitä paikasta joka viimeksi toimi. Kannattaa kuitenkin tallettaa työnsä vähänväliä ettei joutuisi kirjoittamaan pitkää litaniaa uudelleen.
- skriptaamisen merkittävin asia on puhua kaikista asioista niin pitkillä ja kuvaavilla nimillä että ne muistaa kuolemansa jälkeenkin. BASH itse puhuu arvoituksin mutta älä sinä puhu.
- nimissä kannattaa välttää erikoismerkkejä, ääkkösia ja välilyöntejä. Kuitenkin jos selvyys vaatii niin niitä täytyy käyttää mikäli BASH:in saa ne hyväksymään; vaikeuksia ei saa vältellä.
- tietysti skriptien tekeminen on nopeampaa jos muisti pelaa eikä koskaan kohella. Mutta jos ei muista edes perusasioita ja koheltaa vähänväliä tulee työskentelystä vain hirveän hidasta mutta eteneminen on kuitenkin varmaa.

Skriptiajurin backup:ista ei tarvitse huolehtia sillä skriptiajuri kirjoittaa välittömästi kaikki muutoksensa USB-muistitikulle jos muistitikulla on kansio OMATSKRIPTIT. Muistitikun OMATSKRIPTIT kansio voi olla tyhjäkin jolloin sille kirjoitetaan koko kansio OMATSKRIPTIT.
- ominaisuuden saa toimimaan myös SSH:n yli.
- backupin tekeminen kestää skriptiajurin kannalta 2ms.
- backup tehdään jokaiselle muistitikulle joka on liitetty johonkin USB-porttiin mikäli siinä on kansio OMATSKRIPTIT. USB-porteissa voi olla muistitikku tai ei ja niillä voi olla kansio OMATSKRIPTIT tai ei. Backup toimii kaikille käyttäjille, eikä backupin toiminta ei riipu muistitikun nimestä, uuid:stä tai mistään. Tiedostomuodosta ei välitetä kunhan koneessta löytyy ajurit.
- niin pientä muistitikkua ei olekaan ettei se riittäisi, eikä sillä ole väliä minkätyypin USB se on. Siis on mahdollista käyttää monimutkaistakin backup-menetelmää usealle muistitikulle.
- muistitikulla olevasta OMATSKRIPTIT-kansiosta ei koskaan poisteta mitään vaan ainoastaan lisätään. Tällätavoin menetellen siellä on enemmän myös roskaa, mutta toisaalta sellaista vikaa ei voi tulla että jotain katoaa edes melkoisen hölmöilyn seurauksena. Muistitikulla olevan  OMATSKRIPTIT-kansion koon kasvaminen ei aiheuta ongelmia.

Skriptejä tehtäessä ei riitä, että skriptien tekeminen on helppoa ja siihen kelpaakin moni viritelmä. Mutta ongelma ei olekaan skriptien teko sinänsä, vaan se että jokainen ongelma voidaan ratkaista ziljoonalla erilaisella tavalla ja jokaisella on omat vahvuutensa ja heikkoutensa - ja tilanteeseen sopivan menetelmän valintaan tarvitaan opastusta. Tarkoitan että melkein kaikki skriptit ovat väkisin tehtyja ja huomattavasti liian isoja ja hitaita, sillä BASH:in logiikka ei sovi normaalilla tavoilla ajatteleville.   

Skriptiajuri on tehty BASH:illa sen osoittamiseksi että BASH ei ole rajoittunut pieniin skripteihin. Jo kauan on kaiken voinut tehdä käytettävyyden kannalta mielekkäimmällä tavalla sillä skriptiajurin toiminta-nopeus on usein jo turhankin suuri.

Monet järjestelmät kehuvat, että niiden koodi on editoitavissa niillä itsellään, mutta käytännössä niitä ei voi editoida millään tavalla. Sensijaan kehitettäessä skriptiajuriin uusia ominaisuuksia sitä editoidaan poikkeuksetta itsellään.

Skriptit ovat ohjelmia parempia ennenkaikkea järjestelmän hoitamisessa sillä ne ovat lyhyitä ja niissä BASH toimii vain mitättömän ajan sillä pääosa aikaa kuluu ulkoisissa ohjelmissa. Mutta skriptausta kannattaa käyttää myös silloin kun tulevasta ohjelmasta täytyy nopeasti saada mielikuva. Syy skriptien käyttämiseen on se, että skriptit kykenevät kaikkeen samaan kuin expertitkin ja ne toimivat nopeammin ja virheettömämmin. Mutta yksi skripti kykenee vain erittäin rajoitettuun toimintaan joten skriptejä tulee olla tuhansia jo vaatimattomassakin tehtävässä. Mutta suuresta skriptijoukosta valinta on hidasta, ja valinta jo tuhannesta skriptistä on tavanomaisin keinoin hankalaa mutta skriptiajurille tuommoiset mitättömät määrät eivät tunnu mitenkään.

Skriptiajuri hallitseekin skriptejään tiedostopuussa, jossa nimien pituutta tai merkkivalikoimaa ei ole rajoitettu: mikä hyvänsä merkki kelpaa lukuunottamatta merkkiä: /
 
Skriptiajuri pitää kokoajan kirjaa siitä missä se on, joten voi rauhassa painaa ctrl-c tai peräti bootata kun tehtävä skripti villiintyy tai muuttuu hiljaiseksi.

vaikka yleensä onkin yhdentekevää millaisessa koneessa skripti toimii niin usein olisi mukavaa saada se helposti selville - ja joillain harvoilla skripteillä se on "pakko". Skriptiajuri hoitaa  ottaa aina selville koneen piirteitä mutta tulostaa ne sellaiseen paikkaan joka normaalisti on näkymättömissä. Nämä koneesta kertovat viestit saat esiin kun heti skriptiajuri alkaessa toimimaan pyörittää hiiren rullaa. Näyttö palaa normaaliksi heti kun teet jotakin muuta, esimerkiksi painat nuoli-näppäintä.
- skriptiajurin näyttöä voi aina selailla oltaessa pääte-tilassa. Siellä on muunmuassa kaikki ne viestit mitä skriptisi on tehnyt: enää ei tarvitse pähkäillä että mikä viesti siellä näytössä vilahti vaan voi mennä katsomaan. Näitä viestejä voi olla kymmeniä sivuja.
 
- kaiki mitä on joskus tehty löytyy arkistosta. Editoitaessa koodeja tai dokumentteja haetaan arkistosta editoriin myös muutamia viimeisimmistä versioista ja editoitaessa koodeja haetaan editoriin myös käytetyt kirjastot.
- editoitava tiedosto tarkistetaan mentäessä ajamaan skriptiä tai editoimaan skriptiä ja mikäli koodaus-virheitä löytyy mennään editointiin ja viedään lista käännösvirheestä omalle sivulle.
- vastaus jokaiseen skriptiajurin kysymykseen talletetaan historiatietoihin. Jokaiselle kysymykselle on oma historia joten tarvittava löytyy nopeasti. Historiatietoja voi selata nuolinäppäimillä niinkuin normaalistikin tai käyttää etsintää.
- hakuja on monia erilaisia; ja nimenomaan sellaisia hakuja jotka pystyvät löytämään skripteissä olevaa kapulakieltä - internetin hakukoneet eivät muuten pysty.
- kaikki ohjelmointi perustuu kopiointiin vaikkakaan sitä ei tajuta koska kirjastot ovat kopiointi-automaatteja.
- muutokset skriptiajuriin tai sen kirjastoihin tehdään yleensä skriptiajurissa itsessään. Ulkoisia ohjelmilla voi lisätä skriptiajuriin mitä vaan mutta poistamisessa on paljon ehtoja.
- mitään ei koskaan tuhota ellei erikseen pyydetä tuhoamaan. Jokainen tehty versio talletetaan arkistoon omalla numerollaan. Numero on kasvava. Editoitaessa esitetään muutama viimeinen versio.
- arkistoon voi myös mennä kokeilemaan mikä siellä olevista versioista toimii ajettuna parhaiten ja kopioida sen koodi tehtävän skriptin paikalle.
- myös näppäin-versiossa hiirellä on suuri merkitys: sillä valitaan editorissa näytettävä lehti ja hiiren rullalla saa esimerkiksi selattua päätettä; esimerkiksi aloitusviestit saa sillä näkyviin.

 


 
« Viimeksi muokattu: 08.12.16 - klo:16.40 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #1 : 15.02.11 - klo:13.52 »
/home/käyttäjänimi/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkohiirelle

Koodia: [Valitse]
#!/bin/bash   
# Valikkohiirelle (rullahiirelle)  petteriIII 2.4.2013
# Selostus tunnetuista funktioista ja niiden parametreista:
# 1. ValitseValittavistaYksi: [otsikko [avaimet [ValitunNumero]]] . Erittely:
# otsikko=vapaata tekstiä koko toinen rivi näytöllä. Jos se on annettu sitä käytetään mutta jos ei ole niin otsikko muodostetaan automaattisesti. otsikko:sta otetaan CRC-32 muuttujaan crc ja se yksilöikin kutsujan hyvin. Ulkopuolinen ohjelma saattaa käyttää sitä.
# avaimet= merkit 38-157 rivillä 1. Valikkohiirelle ohjelmassa ne eivät ole varsinaisia avaimia, vaan lisä-otsikko
# ValitunNumero= valittuna olevan järjestysnumero.

# 2. ohjeet: kaikki ~/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio tai: Skriptiajuri, näppäinversio" ohje-kansion tiedostot viedään editoriin. Tiedostoja voi lisätä tai poistaa ja Skriptiajuri ottaa muutoksen automaattisesti huomioon.
# ohjeista ei voi esittää akrkistokappaleita editorissa. Arkistokappaleet kuitenkin tehdään paikkaan: ~/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/tiedoston nimi/monotonisesti kasvava arkistonumero

# 3. etsiä_missä_skripti_on_kun_muistaa_sen_nimestä_jotakin                 
# 4. etsiä_kysyttävää_ilmaisua_skriptien_tekstistä
# 5. etsiä_esimerkkirivejä_kuinka_jotakin_käskyä_käytetään
# 6. ajaa_valitun_skriptin

echo -e "funktiot paikasta:"${0%/OMATSKRIPTIT*}"/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkohiirelle  liitetään koodiin"

function ValitseValittavistaYksi () {
function AsetaPaate { 
RivienLuku=$(($(tput lines)-6)) # näytön riviluku. 6 on otsikon+yläpalkin viemä tila
RivinPituus=$(tput cols)        # näyttörivin merkkiluku.
echo -e 'Näyttö-funktio kirjastoa kutsuva ohjelma: ' $(basename "$0")'\nnäytön riviluku:'$RivienLuku'   rivinpituus:'$RivinPituus
# gconftool ja gnome-terminal ovat gnomessa, mate:ssa on mateconftool-2 ja mate-terminal. Seuraava on testi onko mate vai joku muu
[[ $(cat /var/lib/dpkg/status  | grep \ mate-terminal) ]] && (
apu=$(mateconftool-2 -g /apps/mate-terminal/profiles/Default/default_size_columns)
mateconftool-2 -s /apps/mate-terminal/profiles/Default/use_custom_default_size --type bool true
mateconftool-2 -s /apps/mate-terminal/profiles/Default/default_size_columns --type integer 240
mateconftool-2 -s /apps/mate-terminal/profiles/Default/default_size_rows --type integer 60     
mateconftool-2 -s /apps/mate-terminal/profiles/Default/scrollback_unlimited --type bool true # rajoittamaton vieritys 
mateconftool-2 -s /apps/gedit-2/preferences/editor/line_numbers/display_line_numbers --type bool true
[[ $apu = 240 ]] || (echo 'avaa uusi pääte ja käynnistä siinä uudelleen'; sleep 3; killall mate-terminal)
)

[[ $(cat /var/lib/dpkg/status  | grep \ gnome-terminal) ]] && (
apu=$(gconftool -g /apps/gnome-terminal/profiles/Default/default_size_columns)
gconftool -s /apps/gnome-terminal/profiles/Default/use_custom_default_size --type bool true
gconftool -s /apps/gnome-terminal/profiles/Default/default_size_columns --type integer 240 # Näyttörivin maximi pituus
gconftool -s /apps/gnome-terminal/profiles/Default/default_size_rows --type integer 60     # Näyttörivien maximi määrä
gconftool -s /apps/gnome-terminal/profiles/Default/scrollback_unlimited --type bool true
gconftool -s /apps/gedit-2/preferences/editor/line_numbers/display_line_numbers --type bool true
[[ "$apu" = 240 ]] || (echo 'avaa uusi pääte ja käynnistä siinä uudelleen'; sleep 3; killall gnome-terminal)
)
valintalukko=1 # negatiivinen logiikka, valinta on nyt mahdollista suorittaa
# avaimet=''     # ohjelma perisi muuten avaimet edelliseltä ohjelmalta
raja=112\101\116\116\101\114\105\73\73\73
}

function MuutaValittuPunaiseksi {
tput cup 2 $(($RivinPituus-95))
tput sgr0; echo "näpäytä_tästä_käyttöohjeet erikoistoimet  dokumentoi koodaa"
tput cup 0 $(($RivinPituus-45)) #; tput el tyhjää loppurivi
apu=$kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT/'"${Valittavat[ValitunNumero-1]}" # dokumenttien määrää ei pitäisikään näyttää
[[ $ValitunNumero>1 ]] && Tiedostonaika="" && [[ -a $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" ]] && Tiedostonaika=$(stat --printf %y $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}"  | awk '{ print $1" "$2"  "}' | tr -d '\n')           
[[ -f $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" ]] && echo -n ${Tiedostonaika:0:16} && [[ -d $apu ]] && echo -n " Koodeja:"$(ls "$apu" | sort -g | tail -n 1) && tput el
[[ -d $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" ]] && echo "kansiossa tiedostoja:"$(ls $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" | wc -l)"          " 
[[ ${Valittavat[ValitunNumero-1]} = .edellinen_kansio. ]] && tput el
Xkoordinaatti=$(((ValitunNumero - 1 - $(((ValitunNumero - 1) / RivienLuku))) / RivienLuku)); Ykoordinaatti=$((ValitunNumero - $((RivienLuku * Xkoordinaatti -1))+3));tput cup $((Ykoordinaatti - Xkoordinaatti - 2)) $((Xkoordinaatti * SarakkeenPituus));  tput setf 4; echo "${Valittavat[ValitunNumero-1])}"
}

function MuutaKaikkiValintarivitVihreiksi {
tput cup 3 0 ; tput setf 3
cat /home/petteri/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö
}

function TulostaValittavat {
clear
rm /home/petteri/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö
tput sgr0
echo -e 'Skriptiajurin hiiriversio\n'$otsikko'\n'                     
ValittavienLuku=${#Valittavat[@]}
SarakkeidenLuku=$(($((ValittavienLuku-3))/RivienLuku+1))  # oli:SarakkeidenLuku=$(($((ValittavienLuku-2))/RivienLuku+1))
SarakkeenPituus=$((RivinPituus/SarakkeidenLuku))
tput setf 3
for (( Rivi=0; Rivi<=RivienLuku; Rivi++ )) # -1 ei vissiin onnistunut
do
  for (( Sarake=0; Sarake<=SarakkeidenLuku-1; Sarake++ ))   
  do
    naytettava=${Valittavat[Sarake*RivienLuku+Sarake+Rivi]}"                                                                                                  "
    nayttoRivi="$nayttoRivi"${naytettava:0:$SarakkeenPituus}  # mitä sarakkeita näyttörivillä ennestään onkin ja uusi sarake lisää
  done
  echo "${nayttoRivi}"; echo -e "${nayttoRivi}" >> /home/petteri/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö; naytto[$Rivi]=${nayttoRivi:0:$RivinPituus}; nayttoRivi='' 
done 
}

function MuutaValittuNuolinappaimilla {
MuutaValittuPunaiseksi
 echo -en "\e[?1000h"; read -n6 -s -t0.02 key ; echo -en "\e[?1001h"
stty -echo
[[ ${key:3:1} = "a" ]] && MuutaValittua -1  # rullaus ylös
[[ ${key:3:1} = "\`" ]] && MuutaValittua 1  # rullaus alas
if [[ ${key:3:1} = "#" ]]; then valintatehty=1; x=$(LC_CTYPE=C printf '%d' "'${key:4:1}"); y=$(LC_CTYPE=C printf '%d' "'${key:5:1}")
  [[ $y = 33 ]] && [[ $x < 40 ]] && Tapahtuma=palaa && valintatehty=1 && return
  [[ $y = 33 ]] && [[ $x < 70 ]] && Tapahtuma=uusi && valintatehty=1 && return
  [[ $y = 35 ]] && [[ $x > $(($RivinPituus-10)) ]] && Tapahtuma=koodaa && valintatehty=1 && return
  [[ $y = 35 ]] && [[ $x > $(($RivinPituus-18)) ]] && Tapahtuma=dokumentoi && valintatehty=1 && return
  [[ $y = 35 ]] && [[ $x > $(($RivinPituus-36)) ]] && Tapahtuma=erikoistoimet && valintatehty=1 && return
  [[ $y = 35 ]] && [[ $x > $(($RivinPituus-57)) ]] && Tapahtuma=käyttöohjeet && valintatehty=1 && return
  [[ $y > 35 ]] && MuutaKaikkiValintarivitVihreiksi && ValitunNumero=$((y-34+(((RivienLuku+1)*((x-34)/SarakkeenPituus)))-1)) && MuutaValittuPunaiseksi && return
valintatehty=0
fi                                                         
}

function MuutaValittua () {
MuutaKaikkiValintarivitVihreiksi
ValitunNumero=$(($ValitunNumero+$1))
[[ $ValitunNumero -lt 1 ]] && TulostaValittavat && ValitunNumero=1 # TulostaValittavat lisätty
[[ $ValitunNumero -gt $ValittavienLuku ]] && ValitunNumero=$ValittavienLuku # apu->ValittavienLuku; -2 lisätty poistettu
}
 
# function ValitseValittavistaYksi () {
[[ $3 ]] && ValitunNumero=$3
[[ ${#Valittavat} == 0 ]] && echo 'ei ole valittavaa' && sleep 2 && valintatehty=1 && break
AsetaPaate
local otsikko key valintatehty=0 Xkoordinaatti Ykoordinaatti   
[[ ! $ValitunNumero || $ValitunNumero -lt 1 || $ValitunNumero -gt ${#Valittavat[@]} ]] && ValitunNumero=1
setterm -cursor off 
otsikko="$1"; [[ ! "$otsikko" ]] && otsikko='Ohjelma: '$0' pyytää valitsemaan näistä'
crc=$(echo $otsikko | cksum | awk {'print $1'}) # cksum=32bittinen crc, sha1sum ->160bittinen ...
TulostaValittavat
valintatehty=0
Tapahtuma=""
while [ $valintatehty -lt 1 ] ; do MuutaValittuNuolinappaimilla;  done
clear; tput sgr0; stty echo # setterm -reset # värit normaaleiksi # clear lisätty
ValitunTeksti=${Valittavat[ValitunNumero-1]}
[[ ! ${ValitunArvo[ValitunNumero-1]} ]] && ValitunArvo='ei määritelty' || ValitunArvo=${ValitunArvo[ValitunNumero-1]}
}

# loput funktiot ovat Skriptiajuri:n hiiriversiota varten eivätkä sotke mitään. Näppäinversiossa paremmat funktiot?
function etsiä_missä_skripti_on_kun_muistaa_sen_nimestä_jotakin () {
avaimet='palaa Skriptiajuri:en        uusi hakutermi'
while true
do
  clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo; echo
  lue_näppäimistöltä hakusana "mitä ilmausta etsit kansioiden tai skriptien nimistä (teksti voi olla keskelläkin sanaa)?"
  eval Valittavat=(" "$(find /home/petteri/OMATSKRIPTIT |  grep "$hakusana" | grep -v /ARKISTO/ | grep -v *sgml | sed 's/^ */"/g;s/ *$/"/g'))
  ValitunNumero=$(cat $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2)
  ValitseValittavistaYksi "ilmaus löytyi näiden skriptien nimistä: tutki valittu painamalla enter sen kohdalla" "$avaimet"
  [[ $Tapahtuma = "palaa" ]] && break
  [[ $Tapahtuma = "uusi" ]] ||  echo 'editoin tiedostoa: '/home/petteri/OMATSKRIPTIT/palautuspiste "$ValitunTeksti" && gedit "$ValitunTeksti" && break
done
echo $ValitunNumero > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2
}

function etsiä_kysyttävää_ilmaisua_skriptien_tekstistä {
kansio_josta_ei_haeta='\/ARKISTO\/'
clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo; echo ; echo
lue_näppäimistöltä hakusana "mitä ilmausta etsit kaikista omista skripteistä ?"
optiot="-lr" 
apu=${hakusana%% *}
[[ ${hakusana:0:1} = "-" ]] && optiot="-lr"${apu:1} && hakusana=${hakusana#* }
[[ $(echo $hakusana | grep ^man) ]] && $hakusana > ${hakusana:4} && gedit ${hakusana:4} haku=CTRL-f && rm ${hakusana:4} && return
eval Valittavat=($(grep $optiot "$hakusana" $kanta/OMATSKRIPTIT | grep -v $kansio_josta_ei_haeta | grep -v kopio | sed 's/\/home\/petteri\/OMATSKRIPTIT\///g' | sed 's/^ */"/g;s/ *$/"/g'  ))
[[ -f $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2 ]] && ValitunNumero=$(cat $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2)
while true
do
  avaimet='palaa Skriptiajuri:een  uusi hakutermi' # end=palaa Skriptiajuri:en   f2=anna uusi hakutermi
  ValitseValittavistaYksi "ilmaus löytyi näistä skripteistä: valitse editoitava valitsemalla se ja painamalla enter" "$avaimet" 
  [[ $Tapahtuma = "palaa" ]] && break
  [[ $Tapahtuma = "uusi" ]] && etsiä_kysyttävää_ilmaisua_skriptien_tekstistä
  gedit /home/$(whoami)/OMATSKRIPTIT/"$ValitunTeksti"
done
echo $ValitunNumero > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2
}

function etsiä_esimerkkirivejä_kuinka_jotakin_käskyä_käytetään { # lisätty
clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo; echo
lue_näppäimistöltä hakusana "millaisia esimerkkirivejä etsit kaikista omista skripteistä ?"
find ~/OMATSKRIPTIT ! -path '*ARKISTO*' ! -path *sgml -type f  -exec grep "$hakusana" {} \;
read -p 'hiirellä voi vieritää näyttöä. paina enter jatkaakseesi'
}

function ohjeet { # home. kaikkia ohjekansion tiedostoja tarjotaan editoitaviksi. Tiedostoja voi lisätä tai poistaa ja Skriptiajuri ottaa muutoksen automaattisesti huomioon.
# paikassa: $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/<tiedoston nimi>/<monotonisesti kasvava arkistonumero> on kopio kaikista muuttuneista tiedostoista
gedit & # tämä käsky aiheuttaa sen että pääohjelma ei pysähdy tuleviin gedit-käskyihin vaan jatkaa taustalla ilman näppäimiä ja fyysistä näyttöä
täytä_valittavat $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"
for (( n=2; n<=${#Valittavat[@]}-1; n++ )); do 
TiedostonAikaleimaAlussa[$n]=$(stat --printf %y $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}" | awk '{ print $2 }')
gedit $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}"
done
reset; read -p 'paina enter'
# sen varalta että joku ohje on muuttunut lisätään sen kopio arkistoon. Samalla poistuvat nollatut:
täytä_valittavat $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"
for (( n=2; n<=${#Valittavat[@]}-1; n++ )); do
  [[ ! -d $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}" ]] && mkdir -p $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}" && touch $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}"/0
  [[ ${TiedostonAikaleimaAlussa[$n]} = $(stat --printf %y $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}" | awk '{ print $2 }' ) ]] && continue
  Suurin_numero_ohjeissa=$(ls $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}" | sort -g | tail -n 1)
  cp $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}"  $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, hiiriversio"/"${Valittavat[$n]}"/$(($Suurin_numero_ohjeissa+1))
done
}

function ajaa_valitun_skriptin {
[[ $ValitunTeksti = '.edellinen_kansio.' ]] && KansionNimi=$(dirname "$KansionNimi") && echo "$KansionNimi">$kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/KansionNimiAloituksessa && HaeSenRinvinNumeroJollaViimeksiTyöskenneltiinTässäKansiossa "$KansionNimi" && return
[[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && KansionNimi="$KansionNimi"/"$ValitunTeksti" && return
[[ $(echo "$ValitunTeksti" | grep -e '.PDF' -e '.pdf') ]] && evince $kanta/"$KansionNimi"/"$ValitunTeksti" && return # html:lle myös
[[ $(echo "$ValitunTeksti" | grep -e '\.doc' -e .html -e .odt -e .sgml -e .xml) ]] && /usr/bin/libreoffice $kanta/"$KansionNimi"/"$ValitunTeksti" && return
[[ ! -d $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti" ]] && mkdir -p $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti" #?
bash -n $kanta/"$KansionNimi"/"$ValitunTeksti" &>$kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ ! -f $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe ]] && echo "" > $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ $(cat -b $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe) > 0 ]] && echo 'tulkkauskelvoton, mennään koodaamaan' && sleep 0.2 && koodaa && return
[[ $(cat $kanta/"$KansionNimi"/"$ValitunTeksti" | grep \$1) ]] && LueParametrit # jos skriptissä on viittauksia parametreihin käydään lukemassa niitä
clear && echo -e 'suoritan skriptin: '$kanta/"$KansionNimi"/$ValitunTeksti'\n' && bash $kanta/"$KansionNimi"/"$ValitunTeksti" $Parametrit && read -p 'jatkaakseesi paina enter' || ( reset; echo "skriptisi päätyi virheeseen virhe-statuksella: "$? ; read -p "jatkaakseesi paina enter"; /home/petteri/OMATSKRIPTIT/"Skriptiajuri, hiiriversio" )
}
« Viimeksi muokattu: 02.04.13 - klo:07.47 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #2 : 01.03.11 - klo:08.04 »
~/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkonäppäimille

Koodia: [Valitse]
#!/usr/bin/env bash   
# valikkonäppäimille  petteriIII 2.4.2013
# Selostus tunnetuista funktioista ja niiden parametreista:
# 1. ValitseValittavistaYksi: [otsikko [avaimet [ValitunNumero]]] . Erittely:
# otsikko=vapaata tekstiä koko toinen rivi näytöllä. Jos se on annettu sitä käytetään mutta jos ei ole niin otsikko muodostetaan automaattisesti. otsikko:sta otetaan CRC-32 muuttujaan crc ja se yksilöikin kutsujan hyvin. Ulkopuolinen ohjelma saattaa käyttää sitä.
# avaimet= merkit 38-157 rivillä 1. Tämä on tekstiä jossa esiintyy mahdollisten avaimien nimet (f1-f4, home, end, insert ja delete). Kannatta selventää kirjoittamalla mitä mikin tekee: f2=<mitä se tekee> insert=<mitä se tekee> ...   avaimet joiden nimeä ei ole mainittu eivät toimi
# ValitunNumero= valittuna olevan järjestysnumero.

# 2. ohjeet: kaikki ~/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio tai: Skriptiajuri, näppäinversio" ohje-kansion tiedostot viedään editoriin. Tiedostoja voi lisätä tai poistaa ja Skriptiajuri ottaa muutoksen automaattisesti huomioon. Tyhjäämällä ohjesivun se tuhotaan kun editorista poistutaan.
# ohjeista ei voi esittää arkistokappaleita editorissa. Arkistokappaleet kuitenkin tehdään paikkaan: ~/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/tiedoston nimi/monotonisesti kasvava arkistonumero

# 3. etsiä_missä_skripti_on_kun_muistaa_sen_nimestä_jotakin                 
# 4. etsiä_kysyttävää_ilmaisua_skriptien_tekstistä
# 5. etsiä_esimerkkirivejä_kuinka_jotakin_käskyä_käytetään
# 6. ajaa_valitun_skriptin
 

function ValitseValittavistaYksi () {                   
function AsetaPaate () {  # yritetään tehdä päätteen ja geditin asetukset
RivienLuku=$(($(tput lines)-6)) # näytön riviluku. 6 on otsikon+yläpalkin viemä tila
RivinPituus=$(tput cols)        # näyttörivin merkkiluku.
echo -e 'Näyttö-funktio kirjastoa kutsuva ohjelma: ' $(basename "$0")'\nnäytön riviluku:'$RivienLuku'   rivinpituus:'$RivinPituus
# gconftool ja gnome-terminal ovat gnomessa, mate:ssa on mateconftool-2 ja mate-terminal.
[[ $(cat /var/lib/dpkg/status  | grep \ mate-terminal) ]] && (
apu=$(mateconftool-2 -g /apps/mate-terminal/profiles/Default/default_size_columns)
mateconftool-2 -s /apps/mate-terminal/profiles/Default/use_custom_default_size --type bool true
mateconftool-2 -s /apps/mate-terminal/profiles/Default/default_size_columns --type integer 240
mateconftool-2 -s /apps/mate-terminal/profiles/Default/default_size_rows --type integer 60     
mateconftool-2 -s /apps/mate-terminal/profiles/Default/scrollback_unlimited --type bool true # rajoittamaton vieritys 
mateconftool-2 -s /apps/gedit-2/preferences/editor/line_numbers/display_line_numbers --type bool true
[[ $apu = 240 ]] || (echo 'avaa uusi pääte ja käynnistä siinä uudelleen'; sleep 3; killall mate-terminal)
)

[[ $(cat /var/lib/dpkg/status  | grep \ gnome-terminal) ]] && (
apu=$(gconftool -g /apps/gnome-terminal/profiles/Default/default_size_columns)
gconftool -s /apps/gnome-terminal/profiles/Default/use_custom_default_size --type bool true
gconftool -s /apps/gnome-terminal/profiles/Default/default_size_columns --type integer 240 # Näyttörivin maximi pituus
gconftool -s /apps/gnome-terminal/profiles/Default/default_size_rows --type integer 60     # Näyttörivien maximi määrä
gconftool -s /apps/gnome-terminal/profiles/Default/scrollback_unlimited --type bool true
gconftool -s /apps/gedit-2/preferences/editor/line_numbers/display_line_numbers --type bool true
[[ "$apu" = 240 ]] || (echo 'avaa uusi pääte ja käynnistä siinä uudelleen'; sleep 3; killall gnome-terminal)
)
valintalukko=1 # negatiivinen logiikka, valinta on nyt mahdollista suorittaa
raja=112\101\116\116\101\114\105\73\73\73
}

function MuutaValittuPunaiseksi () {
tput sgr0 # värit normaaleiksi
tput cup 0 $(($RivinPituus-42)); tput el # kursorin asettaminen ja loppurivin tyhjääminen
apu=$kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT/'"${Valittavat[ValitunNumero-1]}" # dokumenttien määrää ei pitäisikään näyttää
[[ -f $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" ]] && Tiedostonaika=$(stat --printf %y $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}"  | awk '{ print $1" "$2"  "}' | tr -d '\n') && echo -n ${Tiedostonaika:0:16} && [[ -d $apu ]] && echo -n " Koodi:"$(ls "$apu" | sort -g | tail -n 1)" " 
[[ -d $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" ]] && echo "kansiossa tiedostoja:"$(ls $kanta/"$KansionNimi"/"${Valittavat[ValitunNumero-1]}" | wc -l) 
Xkoordinaatti=$(((ValitunNumero - 1 - $(((ValitunNumero - 1) / RivienLuku))) / RivienLuku)); Ykoordinaatti=$((ValitunNumero - $((RivienLuku * Xkoordinaatti -1))+3));tput cup $((Ykoordinaatti - Xkoordinaatti - 2)) $((Xkoordinaatti * SarakkeenPituus));  tput setf 4; echo "${Valittavat[ValitunNumero-1])}"
}

function MuutaKaikkiValintarivitVihreiksi () {
tput cup 3 0 ; tput setf 3
cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö
}

function TulostaOtsikot () {
clear
tput sgr0
[[ $valintalukko = 1 ]] && echo -n 'enter=valitse tämä   ' || echo -n 'paina nuoliylös-alas  '
echo -e "$avaimet"'\n'$otsikko'\n' 
}

function TulostaValittavat () {
TulostaOtsikot
rm $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö                     
# ValittavienLuku=${#Valittavat[@]}
SarakkeidenLuku=$(($((ValittavienLuku-3))/RivienLuku+1))  # oli: SarakkeidenLuku=$(($((ValittavienLuku-2))/RivienLuku+1))
SarakkeenPituus=$((RivinPituus/SarakkeidenLuku))
tput setf 3
for (( Rivi=0; Rivi<=RivienLuku; Rivi++ ))
do
  for (( Sarake=0; Sarake<=SarakkeidenLuku-1; Sarake++ ))   
  do
    naytettava=${Valittavat[Sarake*RivienLuku+Sarake+Rivi]}"                                                                                                  "
    nayttoRivi="$nayttoRivi"${naytettava:0:$SarakkeenPituus}  # mitä sarakkeita näyttörivillä ennestään onkin ja uusi sarake lisää
  done
  echo "${nayttoRivi}"; echo -e "${nayttoRivi}" >> $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö; nayttoRivi='' 
done 
}

function MuutaValittuNuolinappaimilla () {
MuutaValittuPunaiseksi
read -sn 1 key
stty -echo
[[ -z $key ]] && Tapahtuma='enter' && valintatehty=$valintalukko && valintalukko=0 && return  # enter
set +e
[[ ! ${key#*[PQRSHF23]} ]] && Tapahtuma=${avain[$key]} && valintatehty=${valintasallittu[$key]} # f1,f2,f3,f4,home,end,insert tai delete
[[ ! ${key#*[ABCD]} ]] && MuutaKaikkiValintarivitVihreiksi && tput cup 0,0 && echo -n 'enter=valitse tämä   ' && valintalukko=1 && ${avain[$key]} # nuolinäppäimet
read -sn1 -t .001 key # tuntuu auttavan
set -e
}

function MuutaValittua () {
ValitunNumero=$(($ValitunNumero+$1))
[[ $ValitunNumero -lt 1 ]] && ValitunNumero=1
apu=${#Valittavat[*]}
[[ $ValitunNumero -gt $apu ]] && ValitunNumero=$apu
}
 
# function ValitseValittavistaYksi () {
ValittavienLuku=${#Valittavat[@]}; [[ $ValittavienLuku = 0 ]] && echo "ei valittavia" && Tapahtuma="end" && sleep 2 && return
AsetaPaate
[[ $3 ]] && ValitunNumero=$3 # valintalukko=1 # mikäli on annettu kolme parametria niin entereitä voi kerätä varastoon
avaimet=$2
declare -A valintasallittu avain
avain['A']='MuutaValittua -1' 
avain['B']='MuutaValittua 1'
avain['C']='MuutaValittua '$((RivienLuku+1))
avain['D']='MuutaValittua -'$((RivienLuku+1))
[[ ! $(echo $avaimet | grep f1) ]] && valintasallittu['P']=0 || valintasallittu['P']=1 && avain['P']='f1'
[[ ! $(echo $avaimet | grep f2) ]] && valintasallittu['Q']=0 || valintasallittu['Q']=1 && avain['Q']='f2'
[[ ! $(echo $avaimet | grep f3) ]] && valintasallittu['R']=0 || valintasallittu['R']=1 && avain['R']='f3'
[[ ! $(echo $avaimet | grep f4) ]] && valintasallittu['S']=0 || valintasallittu['S']=1 && avain['S']='f4'
[[ ! $(echo $avaimet | grep home) ]] && valintasallittu['H']=0 || valintasallittu['H']=1 && avain['H']='home'
[[ ! $(echo $avaimet | grep end) ]] && valintasallittu['F']=0 || valintasallittu['F']=1  && avain['F']='end'
[[ ! $(echo $avaimet | grep insert) ]] && valintasallittu['2']=0 || valintasallittu['2']=1 && avain['2']='insert' 
[[ ! $(echo $avaimet | grep delete) ]] && valintasallittu['3']=0 || valintasallittu['3']=1 && avain['3']='delete'
local otsikko key valintatehty=0 Xkoordinaatti Ykoordinaatti   
[[ ! $ValitunNumero || $ValitunNumero -lt 1 || $ValitunNumero -gt ${#Valittavat[@]} ]] && ValitunNumero=1
setterm -cursor off 
otsikko="$1"; [[ ! "$otsikko" ]] && otsikko='Ohjelma: '$0' pyytää valitsemaan näistä'
crc=$(echo $otsikko | cksum | awk {'print $1'}) # cksum=32bittinen crc, sha1sum ->160bittinen ...
TulostaValittavat
valintatehty=0
Tapahtuma=''
while [ $valintatehty -lt 1 ] ; do MuutaValittuNuolinappaimilla;  done
clear; tput sgr0; setterm -reset; stty echo # clear lisätty
ValitunTeksti=${Valittavat[ValitunNumero-1]}
[[ $ValitunTeksti = '.edellinen kansio.' ]] && valintalukko=1
[[ ! ${ValitunArvo[ValitunNumero-1]} ]] && ValitunArvo='ei määritelty' || ValitunArvo=${ValitunArvo[ValitunNumero-1]}
}

# loput funktiot ovat Skriptiajuria varten
function etsiä_missä_skripti_on_kun_muistaa_sen_nimestä_jotakin () {
avaimet='end=palaa Skriptiajuriin        f2=uusi hakutermi'
while true
do
  clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo; echo
  lue_näppäimistöltä hakusana "mitä ilmausta etsit kansioiden tai skriptien nimistä (teksti voi olla keskelläkin sanaa)?"
  eval Valittavat=(" "$(find $kanta/OMATSKRIPTIT |  grep  "$hakusana" | grep -v /ARKISTO/ | grep -v *sgml | sed 's/^ */"/g;s/ *$/"/g'))
  ValitunNumero=$(cat $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2)
  ValitseValittavistaYksi "ilmaus löytyi näiden skriptien nimistä: valitse editoitava näpäyttämällä sitä hiiriosoittimella." "$avaimet"
  [[ $Tapahtuma = "end" ]] && break
  [[ $Tapahtuma = "f2" ]] ||  echo 'editoin tiedostoa: '$kanta/OMATSKRIPTIT/palautuspiste "$ValitunTeksti" && gedit "$ValitunTeksti" && break
done
echo $ValitunNumero > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2
}

function etsiä_kysyttävää_ilmaisua_skriptien_tekstistä { # etsi_näistä, -v ?
clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo
lue_näppäimistöltä hakusana "mitä ilmausta etsit kaikista omista skripteistä ?"
optiot="-lr"; [[ ${hakusana:0:3} = '-i ' ]]  && optiot=${hakusana%% *}lr && hakusana=${hakusana#* }
[[ ${hakusana:0:3} = '-E ' ]]  && optiot=${hakusana%% *}lr && hakusana=${hakusana#* }
eval Valittavat=($(grep $optiot "$hakusana" $kanta/OMATSKRIPTIT | grep -v /ARKISTO/ | grep -v kopio | sed 's/^ */"/g;s/ *$/"/g'  ))
for (( n=0; n<=${#Valittavat[@]}-1 ; n++ )); do Valittavat[$n]=${Valittavat[$n]##*OMATSKRIPTIT\/}; done
[[ -f $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2 ]] && ValitunNumero=$(cat $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2)
while true
do
  avaimet='end=palaa Skriptiajuriin  f2=uusi hakutermi'
  ValitseValittavistaYksi "ilmaus löytyi näistä skripteistä: valitse editoitava nuolinäppäimillä ja paina enter" "$avaimet" 
  [[ $Tapahtuma = "end" ]] && break
  [[ $Tapahtuma = "f2" ]] && etsiä_kysyttävää_ilmaisua_skriptien_tekstistä
  gedit  $kanta/OMATSKRIPTIT/"$ValitunTeksti"
done
echo $ValitunNumero > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku2
}

function etsiä_esimerkkirivejä_kuinka_jotakin_käskyä_käytetään {
clear; cat $kanta/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/grepin_määreet; echo; echo
lue_näppäimistöltä hakusana "millaisia esimerkkirivejä etsit kaikista omista skripteistä ?"
find ~/OMATSKRIPTIT ! -path '*ARKISTO*' ! -path *sgml -type f  -exec grep "$hakusana" {} \;
read -p 'hiirellä voi vieritää näyttöä. paina enter jatkaakseesi'
}

function ohjeet { # home. kaikkia ohjekansion tiedostoja tarjotaan editoitaviksi. Tiedostoja voi lisätä tai poistaa ja Skriptiajuri ottaa muutoksen automaattisesti huomioon.
# paikassa: $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/<tiedoston nimi>/<monotonisesti kasvava arkistonumero> on kopio kaikista muuttuneista tiedostoista
gedit & # tämä käsky aiheuttaa sen että pääohjelma ei pysähdy tuleviin gedit-käskyihin vaan jatkaa taustalla ilman näppäimiä ja fyysistä näyttöä
täytä_valittavat $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"
for (( n=2; n<=${#Valittavat[@]}-1; n++ )); do 
TiedostonAikaleimaAlussa[$n]=$(stat --printf %y $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}" | awk '{ print $2 }')
gedit $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}"
done
reset; read -p 'paina enter'
# sen varalta että joku ohje on muuttunut lisätään sen kopio arkistoon. Samalla poistuvat tyhjätyt ohjeet
täytä_valittavat $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"
for (( n=2; n<=${#Valittavat[@]}-1; n++ )); do
  [[ ! -d $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}" ]] && mkdir -p $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}" && touch $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}"/0
  [[ ${TiedostonAikaleimaAlussa[$n]} = $(stat --printf %y $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}" | awk '{ print $2 }' ) ]] && continue
  Suurin_numero_ohjeissa=$(ls $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}" | sort -g | tail -n 1)
  cp $kanta/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}"  $kanta/OMATSKRIPTIT/OHJEITA/ARKISTO/SKRIPTIT/"Skriptiajuri, näppäinversio"/"${Valittavat[$n]}"/$(($Suurin_numero_ohjeissa+1))
done
}

function ajaa_valitun_skriptin {
# [[ $ValitunTeksti = '.edellinen_kansio.' ]] && KansionNimi=$(dirname "$KansionNimi") && echo "$KansionNimi">$kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/KansionNimiAloituksessa && HaeSenRinvinNumeroJollaViimeksiTyöskenneltiinTässäKansiossa "$KansionNimi" && return
[[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && KansionNimi="$KansionNimi"/"$ValitunTeksti" && return
[[ $(echo "$ValitunTeksti" | grep -e '.PDF' -e '.pdf') ]] && evince $kanta/"$KansionNimi"/"$ValitunTeksti" && return
[[ $(echo "$ValitunTeksti" | grep -e '\.doc' -e .html -e .odt -e .sgml -e .xml) ]] && /usr/bin/libreoffice $kanta/"$KansionNimi"/"$ValitunTeksti" && return
# [[ ! -d $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti" ]] && mkdir -p $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"
bash -n $kanta/"$KansionNimi"/"$ValitunTeksti" &>$kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ ! -f $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe ]] && echo "" > $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ $(cat -b $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe) > 0 ]] && echo 'tulkkauskelvoton, mennään koodaamaan' && sleep 0.5 && koodaa && return
[[ $(cat $kanta/"$KansionNimi"/"$ValitunTeksti" | grep \$1) ]] && LueParametrit # jos skriptissä on viittauksia parametreihin käydään lukemassa niitä
clear && echo -e 'suoritan skriptin: '$kanta/"$KansionNimi"/$ValitunTeksti'\n' && time bash $kanta/"$KansionNimi"/"$ValitunTeksti" $Parametrit && read -p 'jatkaakseesi paina enter' || ( reset; echo "skriptisi päätyi virheeseen virhe-statuksella: "$? ; read -p "jatkaakseesi paina enter"; $kanta/OMATSKRIPTIT/"Skriptiajuri, näppäinversio" )
}
« Viimeksi muokattu: 02.04.13 - klo:10.01 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #3 : 11.04.11 - klo:18.55 »
liitä koodi tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot1

IDE1funktiot ja IDE2funktiot tarjoavat skriptiajurille sen tarvitsemat funktiot.

Koodia: [Valitse]
#!/bin/bash  
# petteriIII 2.4.2013 # trap 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 notify-send -hint?????  xmessage
echo -e "funktiot paikasta:"${0%/OMATSKRIPTIT*}"/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot1 liitetään koodiin"

function tehdä_uuden_skriptin_tähän_kansioon () {
while true; do
  lue_näppäimistöltä SkriptinNimi "mikä tulee uuden skriptin nimeksi: "
  [[ ! -f $kanta/"$KansionNimi"/"$SkriptinNimi" ]] && break || echo 'sen niminen on jo' && sleep 2
done
etsi_samannimiset_skriptit "$SkriptinNimi"
[[ ! $SkriptinNimi ]] && return
echo -e '#!/bin/bash'>$kanta/"$KansionNimi"/"$SkriptinNimi"
gedit $kanta/"$KansionNimi"/"$SkriptinNimi"
muuta_uusi_nimi_valituksi
}

function etsi_samannimiset_skriptit () {
avaimet="end=palaa Skriptiajuriin jatkamaan skriptintekoa           home=peru skriptinteko"
hakusana="$1"
ValitunNumero=1
eval Valittavat=(" "$(find $kanta/OMATSKRIPTIT |  grep  "$hakusana" | grep -v /ARKISTO/ | grep -v *sgml | sed 's/^ */"/g;s/ *$/"/g'))
while true
do  
  [[ ! ${Valittavat[0]} ]] && break
  ValitseValittavistaYksi "näillä skripteillä on samankaltainen nimi: katso enteriä painamalla onko joku samanlainen kuin se minkä aiot tehdä" "$avaimet"
  [[ $Tapahtuma = "end" ]] && break
  [[ $Tapahtuma = "home" ]] && SkriptinNimi="" && return
  gedit "$ValitunTeksti"
  let ValitunNumero++
done
}

function rajoittaa_tämän_skriptin_arkistossa_koodien_lukua {
for apu in SKRIPTIT # dokumentteja tuskin kertyy rajoitettavaksi
do
  echo -n 'ARKISTO/'$apu/"$ValitunTeksti"' tilatarve sanoja: '; (echo 0; find $kanta/"$KansionNimi"/ARKISTO/$apu/"$ValitunTeksti" -printf '%s +\n'; echo p) | dc
  Suurin_numero=$(($(ls --ignore=*'_dokumentti' $kanta/"$KansionNimi"/ARKISTO/$apu/"$ValitunTeksti" | sort -g | tail -n 1)-10))
  Pienin_numero=$(ls --ignore=*'_dokumentti' --ignore=ARKISTO $kanta/"$KansionNimi"/ARKISTO/$apu/"$ValitunTeksti" | sort -g | head -n 1)
  [[ Suurin_numero-Pienin_numero -gt 99 ]] && echo $apu'  ARKISTO-kopioiden lukumäärä: '$((Suurin_numero-Pienin_numero))'  vähennetään 99:ään' || echo 'ei vähennettävää'
  for (( n=Pienin_numero; n<=Suurin_numero-99; n++ ));do
    [[ -f $kanta/"$KansionNimi"/ARKISTO/$apu/"$ValitunTeksti"/$n ]] && rm $kanta/"$KansionNimi"/ARKISTO/$apu/"$ValitunTeksti"/$n
  done
done
read -p 'paina enter jatkaakseesi'
}

function tehdä_uuden_kansion_tähän_kansioon () {
lue_näppäimistöltä UusiKansio "mikä tulee uuden kansion nimeksi: "
UusiKansio=$(echo "$UusiKansio" | tr [:lower:] [:upper:])
echo 'Luon kansiot nimeltä: '$kanta/"$KansionNimi"/"$UusiKansio"' ja sille arkistot'
mkdir -p $kanta/"$KansionNimi"/"$UusiKansio"/ARKISTO/{SKRIPTIT,DOKUMENTIT,HISTORIAT,POISTETUT}
echo 1 > $kanta/"$KansionNimi"/"$UusiKansio"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
}

function poistaa_tämän_valitun_kohdan () {
echo 'siirrän: '$kanta/"$KansionNimi"/"$ValitunTeksti"'  POISTETTUIHIN. Sieltä se löytyy jos haluat takaisin'
[[ ! -d $kanta/"$KansionNimi"/ARKISTO/POISTETUT ]] && mkdir $kanta/"$KansionNimi"/ARKISTO/POISTETUT
mv $kanta/"$KansionNimi"/"$ValitunTeksti" $kanta/"$KansionNimi"/ARKISTO/POISTETUT/"$ValitunTeksti"
# rm -R $kanta/"$KansionNimi"/ARKISTO/{SKRIPTIT,DOKUMENTIT,HISTORIAT}/"$ValitunTeksti"  
sleep 1
}

function muuttaa_tämän_kohdan_nimeä () {
SkriptinNimi="$ValitunTeksti"
lue_näppäimistöltä  SkriptinNimi 'Nimeämisen voi tehdä ainoastaan samaan kansioon. Nimi on nyt: '"$ValitunTeksti""\nmiksi haluat muuttaa sen: "
mv $kanta/"$KansionNimi"/"$ValitunTeksti" $kanta/"$KansionNimi"/"$SkriptinNimi"
[[ -f $kanta/"$KansionNimi"/"$SkriptinNimi" ]] && ( # tiedostosta kyseenollen arkistot uudellen-nimetään myös # rivi lisätty; kokeile toiminta ja poista kommentti
mv $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti" $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$SkriptinNimi"
mv $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"_dokumentti $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$SkriptinNimi"_dokumentti
mv $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti" $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$SkriptinNimi"
mv $kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$ValitunTeksti" $kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$SkriptinNimi" )
muuta_uusi_nimi_valituksi
}

function siirtää_osoitettavaan_kansioon_osoitettavat_kansiot_tai_skriptit () {  
KansioJohonSiirretaan="OMATSKRIPTIT"
avaimet="valitse kansio johon siirretään ja paina f3 kun olet siinä kansiossa     f2=palaa Skriptiajuriin"
while true
do  
  täytä_valittavat "$KansioJohonSiirretaan"
  ValitseValittavistaYksi "Nyt ollaan kansiossa: ""$KansionNimi" "$avaimet" 1 valinta
  [[ $Tapahtuma = f3 ]] && break
  [[ $Tapahtuma = f2 ]] && return
  [[ $ValitunTeksti = ".edellinen_kansio." ]] && KansioJohonSiirretaan=$(dirname "$KansioJohonSiirretaan") && KansionNimi="$KansioJohonSiirretaan"
  [[ -d "$KansioJohonSiirretaan"/"$ValitunTeksti" ]] && KansioJohonSiirretaan="$KansioJohonSiirretaan"/"$ValitunTeksti" && KansionNimi="$KansioJohonSiirretaan"
done
KansionNimi='OMATSKRIPTIT'
avaimet="f3=lopeta  f4=siirrä tämä"
while true
do
  täytä_valittavat $kanta/"$KansionNimi"
  ValitseValittavistaYksi "Valittu siirretään painettaessa f4 kansioon:""$KansioJohonSiirretaan" "$avaimet"
  [[ $ValitunTeksti = '.edellinen kansio.' ]] && KansionNimi=$(dirname "$KansionNimi") && continue
  [[ $Tapahtuma = f3 ]] && return
  [[ $Tapahtuma = 'enter' ]] && [[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && KansionNimi=/"$KansionNimi"/"$ValitunTeksti"
  [[ $Tapahtuma = f4 ]] && {
  [[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] &&  mv -u $kanta/"$KansionNimi"/"$ValitunTeksti"  "$KansioJohonSiirretaan"/"$ValitunTeksti" && continue
    mv -u $kanta/"$KansionNimi"/"$ValitunTeksti"  "$KansioJohonSiirretaan"/"$ValitunTeksti"
    mv -u $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"  "$KansioJohonSiirretaan"/ARKISTO/SKRIPTIT/"$ValitunTeksti" # tiedostosta kyseenollen arkistot siirretään myös
    mv -u $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"  "$KansioJohonSiirretaan"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"
    mv -u $kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$ValitunTeksti"  "$KansioJohonSiirretaan"/ARKISTO/HISTORIAT/"$ValitunTeksti"    
                           }
done
}


 
function koodaa { # f2
[[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && echo kansiota ei voi koodata. Valinta siirtyy takaisin tiedoston kohdalle && read -p 'paina enter' && continue
[[ $(echo "$KansionNimi" | grep ARKISTO) ]] && apu=$arkistoonpoikettu/"${KansionNimi##*\/}" && gedit $kanta/"$KansionNimi"'/'"$ValitunTeksti" "$apu" && continue # toimia ARKISTOssa ei arkistoida, ainoastaan käydään hakemassa koodi 178 uusikoe
[[ ! -f $kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT/'"$ValitunTeksti"/1 ]] && cp $kanta/"$KansionNimi"/"$ValitunTeksti"  $kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT'/"$ValitunTeksti"'/'1
Suurin_numero=$(ls $kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT/'"$ValitunTeksti" | sort -g | tail -n 1)
apu=$kanta/\'"$KansionNimi"\'/\'"$ValitunTeksti"\'
for n in $(ls --hide=0 $kanta/"$KansionNimi"/'ARKISTO/SKRIPTIT/'"$ValitunTeksti" | sort -g | tail -n 6); do apu="$apu"' '$kanta/\'"$KansionNimi"\'/'ARKISTO/SKRIPTIT/'\'"$ValitunTeksti"\'/$n; done
## laheta kirjasto-funktion kopio arkistoon mikäli kirjastoa kutsutaan
funktiokirjasto=$(grep  FUNKTIOKIRJASTO $kanta/"$KansionNimi"'/'"$ValitunTeksti" | grep -v ARKISTO | awk {'print $2'}  | tr "\n" "  " );  
[[ "$KansionNimi" = OMATSKRIPTIT/FUNKTIOKIRJASTO ]] && funktiokirjasto='' # funktiokirjastossa ei liitetä toisia kirjastoja
[[ $funktiokirjasto ]] && {
apu="$apu"' '"$funktiokirjasto"; echo # lisää kirjastot editoitaviin
}
# apuu testaa onko kyseessä skripti
apuu=$(cat $kanta/"$KansionNimi"/"$ValitunTeksti" | awk '{print $1}'); [[ $(echo ${apuu:2:5}) = "/bin/" ]] && bash -n $kanta/"$KansionNimi"/"$ValitunTeksti" &>$kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ -f $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe ]] && [[ $(cat -b $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe) < 1 ]] && rm $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
[[ -f $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe ]] && apu="$apu"" "$kanta/\'"$KansionNimi"\'/ARKISTO/SKRIPTIT/\'"$ValitunTeksti"\'/virhe
TiedostonAikaleimaAlussa=$(stat --printf %y $kanta/"$KansionNimi"/"$ValitunTeksti" | awk '{ print $2 }')
eval gedit "$apu"
while [ $TiedostonAikaleimaAlussa = $(stat --printf %y $kanta/"$KansionNimi"/"$ValitunTeksti" | awk '{ print $2 }' ) ]; do clear; read -t 1 -N 1 -p "paina näppäimistöstä jotain nappulaa" apu; [[ $apu ]] && TiedostonAikaleimaAlussa=1; done
# wait $! # $!=edellisen prosessin PID. Wait odottaa prosessin PID loppumista.
[[ -f $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe ]] && rm $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/virhe
DIFF=$(diff $kanta/"$KansionNimi"/"$ValitunTeksti"  $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"'/'$Suurin_numero )
[[ "$DIFF" != "" ]] && cp $kanta/"$KansionNimi"/"$ValitunTeksti"  $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"'/'$(($Suurin_numero+1))
echo ""
}

function dokumentoi { # f4
[[ $(echo "$KansionNimi" | grep ARKISTO) ]] && gedit $kanta/"$KansionNimi"'/'"$ValitunTeksti" $kanta/"$KansionNimi"'/'"${KansionNimi##*\/DOKUMENTIT\/}_dokumentti" && continue # ehdon tarkoitus:toimia ARKISTOssa ei arkistoida
[[ -d "$KansionNimi"/"$ValitunTeksti" ]] && echo 'kansion dokumentti' && sleep .1
[[ ! -d $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti" ]] && mkdir -p $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"
[[ ! -f $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/0 ]] && touch $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/0
Suurin_numero=$(ls --hide="$ValitunTeksti"'_dokumentti' $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti" | sort -g | tail -n 1)
apu=''
for n in $(ls --hide=*_dokumentti --hide=0 $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti" | sort -g | tail -n 6); do  apu="$apu"$kanta"/"\'"$KansionNimi"\'/ARKISTO/DOKUMENTIT/\'"$ValitunTeksti"\'/$n' '; done
TiedostonAikaleimaAlussa=$(stat --printf %y $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"'_dokumentti' | awk '{ print $2 }' )
eval gedit $kanta/\'"$KansionNimi"\'/ARKISTO/DOKUMENTIT/\'"$ValitunTeksti"\'/\'"$ValitunTeksti"\'_dokumentti\  $apu
while [ $TiedostonAikaleimaAlussa = $(stat --printf %y $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"'_dokumentti' | awk '{ print $2 }' ) ]; do clear; read -t 1 -N 1 -p "paina näppäimistöstä jotain nappulaa" apu; [[ $apu ]] && TiedostonAikaleimaAlussa=1; done
DIFF=$(diff $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"_dokumentti  $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/$Suurin_numero )
[[ "$DIFF" != "" ]] && cp $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"'_dokumentti'  $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/$(($Suurin_numero+1))
reset;  
}

function hexeditoida_osoitettua_skriptiä { bless $kanta/"$KansionNimi"/"$ValitunTekstiTalteen"; }
« Viimeksi muokattu: 21.09.13 - klo:13.35 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #4 : 13.04.11 - klo:07.32 »
liitä koodi tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot2
Koodia: [Valitse]
#!/bin/bash  
# petteriIII 2.4.2013
echo -e "funktiot paikasta:"${0%/OMATSKRIPTIT*}"/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot2 liitetään koodiin"

function lue_näppäimistöltä () { # Vanhoja vastauksia voi selata ja editoida. Historiatiedosto on nimetty kysymyksen tekstin mukaan. Jokaisessa kansiossa on omat historiatiedostot.
# kutsu: lue_näppäimistöltä <kysyttävän muuttujan nimi> <kysymysteksti jonka merkkivalikoimaa ei ole rajoitettu> . Kysytyn muuttujan arvo tosiaan muuttuu.
historiatiedosto=$kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$2"
[[ ! -f "$historiatiedosto" ]] && echo 'historian alku' > "$historiatiedosto"   # kysymykselle luodaan kysymyksen tekstin mukainen historia-tiedosto # clear
apu=$(eval echo \$$1)
[[ "$apu" != $(tail -1  "$historiatiedosto") ]] &&  echo "$apu" >>  "$historiatiedosto" # kysytty arvo viedään heti historiaan josta sitä voi siis kutsua jo ensimmäisellä kerralla
echo -e "\nEdellisiä vastauksia voi selailla nuolinäppäimillä. Myös editointi toimii. Kirjoita vaikkei kysymysmerkkiä näykään"
echo -e "ctrl-r tuo esiin historian normaalin reverse-search:in. Jos annat pelkästään ¤ niin palataan Skriptiajuriin\n"$2
HISTFILE="$historiatiedosto"
set -o history
read -e $1 # $1 on muuttujan nimi
HISTFILE=~/.bash_history
set -o history
[[ $(eval echo \$$1) = ¤ ]] && $kanta/OMATSKRIPTIT/"Skriptiajuri, näppäinversio" # mahdollinen ongelma
eval echo \$$1 >>  "$historiatiedosto" # arvo menee sekä historistiedostoon että palautuu kysyttyyn muuttujaan $1
}
 
function täytä_valittavat () {
kansio=$@ # kun listattavaksi tulee kansio jonka nimessä on välilyöntejä siirtyy jokainen sana omassa parametrissaan ja ne täytyy liittää yhteen
find "$kansio" -size 0b -delete; find "$kansio" -type f -name ?*'\~' -delete; find "$kansio" -type f -name delme -delete
[[ $(echo "$kansio" | grep ARKISTO) ]] && eval Valittavat=(".edellinen_kansio." " "     $(ls "$kansio" -Qv --group-directories-first)) || eval Valittavat=(".edellinen_kansio." " "     $(ls "$kansio" -Q --group-directories-first))
}

function HaeSenRinvinNumeroJollaViimeksiTyöskenneltiinTässäKansiossa() {
ValitunNumero=1
[[ ! -d $kanta/"$KansionNimi"/ARKISTO ]] && mkdir $kanta/"$KansionNimi"/ARKISTO && echo 1 > $kanta/"$KansionNimi"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
[[ -f $kanta/"$KansionNimi"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa ]] && ValitunNumero=$(cat $kanta/"$KansionNimi"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa)
}

function synkronoida_kovalevyn_ja_tikun_omatskriptit {
lue_näppäimistöltä kansio "mikä on kansion nimi tikulla (tyhjä nimi käy myös): "
rsync --existing -arcuv /media/tikku/$kansio/OMATSKRIPTIT ~
rsync --existing -arcuv ~/OMATSKRIPTIT /media/tikku/$kansio
read -p 'paina enter jatkaakseesi'
}

function LueParametrit () { lue_näppäimistöltä Parametrit "$ValitunTeksti"" saattaa vaatia parametreja. Annapa niitä jos asiallisena pidät:"; }

function VarmistaEttäArkistotOnTehty () {
[[ $(echo "$KansionNimi"/"$ValitunTeksti" | grep /ARKISTO) ]] && return # ARKISTOon ei tehdä arkistoa
[[ -d $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && [[ ! -d $kanta/"$KansionNimi"/"$ValitunTeksti"/ARKISTO/POISTETUT ]] && mkdir -p $kanta/"$KansionNimi"/"$ValitunTeksti"/ARKISTO/POISTETUT && return
[[ ! -d $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti" ]] && ( mkdir -p $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"; touch $kanta/"$KansionNimi"/ARKISTO/SKRIPTIT/"$ValitunTeksti"/0 )
[[ ! -d $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti" ]] && ( mkdir -p $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"; touch $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/0; echo " " > $kanta/"$KansionNimi"/ARKISTO/DOKUMENTIT/"$ValitunTeksti"/"$ValitunTeksti"_dokumentti )
# tavitaanko enää? [[ ! -d $kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$ValitunTeksti" ]] && mkdir -p $kanta/"$KansionNimi"/ARKISTO/HISTORIAT/"$ValitunTeksti"
echo '' # funktiossa on ehdottomasti tehtävä jotakin  ja noista muista lauseista ei ehkä suoriteta yhtään, ehdollisia kun ovat
}

function TalletaSenRinvinNumeroJollaNytTyöskenneltiinTässäKansiossa() {
echo $ValitunNumero > $kanta/"$KansionNimi"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa #koe
}

function TalletaMistäKansiostaEnsikerrallaAloitetaan {
apu=${KansionNimi%%[[:alnum:]]*}; KansionNimi=${KansionNimi:${#apu}} # siistitään kansionnimi alkamaan aakkosnumerolla
apu=${KansionNimi%[[:alnum:]]*}; KansionNimi=${KansionNimi:0:$((${#apu}+1))} # siistitään kansionnimi päättymään aakkosnumeroon
echo "$KansionNimi">$kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/KansionNimiAloituksessa
}

function muuttaa_tämän_kansion_nimen_suurille_kirjaimille () {
SkriptinNimi="$ValitunTeksti"
SkriptinNimi=$(echo "$SkriptinNimi" | tr [:lower:] [:upper:])
mkdir $kanta/"$KansionNimi"/"$SkriptinNimi"
cp -rf $kanta/"$KansionNimi"/"$ValitunTeksti"/*  $kanta/"$KansionNimi"/"$SkriptinNimi"/; rm $kanta/"$KansionNimi"/"$ValitunTeksti"  # ARKISTOT seuraa mukana
muuta_uusi_nimi_valituksi
}

function muuta_uusi_nimi_valituksi {
täytä_valittavat $kanta/"$KansionNimi"
for (( n=1; n<=${#Valittavat[@]}; n++ )); do [[ $SkriptinNimi = "${Valittavat[n-1]}" ]] && break; done
echo $n > $kanta/"$KansionNimi"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa # kokeiltava toimiiko
}

function sovellusvalikko {
[[ -f $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku1 ]] && ValitunNumero=$(cat $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku1)
avaimet="end=palaa Skriptiajuriin   home=lopeta Skriptiajuri"
Valittavat=('tehdä uuden skriptin tähän kansioon' 'tehdä uuden kansion tähän kansioon' 'poistaa tämän valitun kohdan' 'siirtää osoitettavaan kansioon osoitettavat kansiot tai skriptit' 'muuttaa tämän kohdan nimeä' 'muuttaa tämän kansion nimen suurille kirjaimille' ' ' 'etsiä esimerkkirivejä kuinka jotakin käskyä käytetään' 'etsiä kysyttävää ilmaisua skriptien tekstistä' 'etsiä missä skripti on kun muistaa sen nimestä jotakin' 'synkronoida kovalevyn ja tikun omatskriptit' 'rajoittaa tämän skriptin arkistossa koodien lukua' 'hexeditoida osoitettua skriptiä' 'ajaa valitun skriptin' 'muuttaa sanan kaikkialla OMATSKRIPTIT kansiossa' 'hakea man sivun ss64 comista' 'etsiä millä man_sivuilla puhutaan siitä toiminnosta jota pitäisi käyttää' 'etsiä skriptistä kontrollimerkit' 'kuvata tiedosto graafisesti')
ValitunTekstiTalteen=$ValitunTeksti
ValitseValittavistaYksi "Minkä toiminnon haluat suorittaa tälle: ""$ValitunTeksti" "$avaimet"
[[ $Tapahtuma = end ]] && return
[[ $Tapahtuma = home ]] && exit
Toimi="$ValitunTeksti"
ValitunTeksti=$ValitunTekstiTalteen
echo $ValitunNumero > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/haku1
$(echo $Toimi  | tr ' ' _ ) # välilyönnit muutetaan alleviivauksiksi.  huomioi että tämä on funktiokutsu
}

function kuvata_tiedosto_graafisesti () {
  gnuplot <<_EOF_
    set term postscript enhanced color
    set output "$kanta/testResults.dat.eps"
    set title 'testResults'
    p "$kanta/testResults.dat" u 1:2 w l
_EOF_
evince $kanta/testResults.dat.eps
}

function etsiä_skriptistä_kontrollimerkit () {
echo "Kontrollimerkit ovat joskus tarpeellisia eivätkä tarpeettomatkaan aina aikaansaa vikoja, mutta joskus ne invalidisoivat ja lisäksi niin ettei se näy ja usein ei huomaa etsiä."
echo "Ensiksi etsitään kontrollimerkit tyyppiä \n, nämä ovat yleensä tarpeellisia:"
[[ -f $kanta/"$KansionNimi"/"$ValitunTeksti" ]] && cat $kanta/"$KansionNimi"/"$ValitunTeksti" | tr -dc '[:cntrl:]' | od -c && echo && echo
echo 'Ja sitten kontrollimerkit tyypiltään:  M- ja: C- (Nämä ovat yleensä merkki "kontrollimerkeistä" ja usein tarpeettomia. Huomioi että ääkköset on poistettu)'; echo
cp $kanta/"$KansionNimi"/"$ValitunTeksti" /tmp/delme1
cat /tmp/delme1 | tr -d äöÄÖ > /tmp/delme2
cat -v /tmp/delme2 | grep -e M- -e C-
#    M-
read -p 'paina enter selattuasi'
}


function etsiä_millä_man_sivuilla_puhutaan_siitä_toiminnosta_jota_pitäisi_käyttää () {
lue_näppäimistöltä kiinnostuksen_aihe "mistä man-sivuilla pitäisi puhua: "
apropos $kiinnostuksen_aihe
read -p 'paina return'
}

function muuttaa_sanan_kaikkialla_OMATSKRIPTIT_kansiossa () {
echo "tämä toiminta vaatii koodin puukottamista. Koodi on paikassa: ~/OMATKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot2. Suojele välilyönnit ja erikoismerkit kenolla. Toiminta kestää noin minuutin jona aikana tulostuu yksi"
read -p "tai useampi kysymysmerkki. Muutettuasi koodia sammuta Skriptiajuri ja aloita sitten uudestaan. Aloittaakseesi paina enter"
# muutoslausekkeen selvitys: $'g/mikä/s//miksi/g\nw\nq' . Vain mikä ja miksi muutetaan.
shopt -s globstar
for file in $kanta/OMATSKRIPTIT/**/*; do
    [[ -f $file ]] && ed -s "$file" <<< $'g/IDE\ BASH-skripteille/s//Skriptiajuri/g\nw\nq'
done
shopt -u globstar
}

function hakea_man_sivun_ss64_comista () {
Valittavat=($(cat /home/petteri/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/käskyluettelo))
ValitseValittavistaYksi "valitse mistä käskystä haluat man-sivun"
firefox  http://ss64.com/bash/$ValitunTeksti.html
}

function muodosta_Skriptiajurin_tiedostorakenne () {
mkdir -p $kanta/OMATSKRIPTIT/ARKISTO/{SKRIPTIT,DOKUMENTIT,HISTORIAT,ASETUKSET,APUTIEDOSTOT}
mkdir -p $kanta/OMATSKRIPTIT/{"KOE- JA ESIMERKKISKRIPTIT",FUNKTIOKIRJASTO,OHJEITA}/ARKISTO/{SKRIPTIT,DOKUMENTIT,HISTORIAT}
echo "OMATSKRIPTIT" > $kanta/OMATSKRIPTIT/ARKISTO/ASETUKSET/KansionNimiAloituksessa
echo 1 > ~/OMATSKRIPTIT/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
echo 1 > ~/OMATSKRIPTIT/"KOE- JA ESIMERKKISKRIPTIT"/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
echo 1 > ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
echo 1 > ~/OMATSKRIPTIT/OHJEITA/ARKISTO/ViimeksiValittuSkriptiTässäKansiossa
echo " " > ~/OMATSKRIPTIT/ARKISTO/APUTIEDOSTOT/näyttö
}

function command_not_found_handle () {
# käyttöjärjestelmä kutsuu automaattisesti tämännimistä funktiota mikäli skriptissä viitataan käskyyn jollaista ei löydy.
komennon_nimi=$1
shift
echo "ohjelma:"${BASH_SOURCE}" Rivino:"${BASH_LINENO}
echo "seuraavaa käskyä ei löydy: \""$komennon_nimi\"""
echo "käskyn argumentit ovat: ""$@"
echo
kaskysta_on_puhuttu_paketeissa=$(apt-cache search $komennon_nimi)
[[ $(echo $kaskysta_on_puhuttu_paketeissa | grep ^$1) ]] && paketin_nimi=$(echo $kaskysta_on_puhuttu_paketeissa | grep ^$1) ||
paketin_nimi= $(echo $kaskysta_on_puhuttu_paketeissa | awk {'print $1'})
echo " paketin määrittelyä: "$paketin_nimi
sudo apt-get install ${komennon_nimi} || echo "siitä on puhuttu paketeissa: "$kaskysta_on_puhuttu_paketeissa
exit
}

 
« Viimeksi muokattu: 02.04.13 - klo:14.35 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #5 : 04.05.11 - klo:06.06 »
Laita seuraava koodi paikkoihin: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, näppäinversio/arkistonkäyttö   ja: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, hiiriversio/arkistonkäyttö
Koodia: [Valitse]
Arkistoon talletetaan melkein kaikki tekemisesi ja siellä ne pysyvät kunnes erikseen poistetaan. Näin senvuoksi että usein skriptiä tehdessä täytyy kokeilla kuinka skriptiin saa halutun toiminnon ja kokeilujen seurauksethan ovat usein sellaiset että kaikki ehjäkin hajoaa ja jäljelle jää vain kaipaus siitä että saisi sen vanhan tilanteen takaisin.

Siinä lakanassa joka tulee esiin skriptiä editoitaessa on numeroituja sivuja. Nämä numerot ovat arkistointinumeroita ja se suurin numero on sama kuin se mitä parhaillaan käsittelet - kun poistut koodaamisesta niin mikäli skripti muuttui vähänkin niin editoidusta versiosta tulee seuraava numero. Kun siis menet ARKISTOon sillä kansiotasolla jolla skripi on ja valitset sieltä: skriptit niin esitetään mistä kaikista skripteistä sillä kansiotasolla on arkisto-kopioita. Valitse se skripti jota käsittelet jolloin esitetään sen skriptin arkistonumerot. Jos muistat mikä sen jotenkin toimivan arkisto-numero on niin kun valitset sen niin gedit:iin luetaan tämä arkistoitu skripti ja se pöhköksi editoitu versio - kopioi se, talleta ja peräydy ARKISTO:sta sille perustasolle ja jatka skriptintekoa - se on nyt se kauan sitten jotenkin toiminut versio.

Mutta joskus et muista sitä numeroa ihan tarkkaan: silloin voit koodata niitä arkistoituja kopioita - jos skripti ei näytä oikealta niin palaa tekemättä mitään ja koodaa jotain muuta numeroa - kyllä oikea lopulta löytyy - ja sitten vain kopiointi, talletus ja perääntyminen.

Mutta joskus ei oikeaa skriptiä löydä sittenkään - sitten vain ajamaan niitä arkistokopioita ja kun joku toimii samallatavoin nikotellen kuin aikoinaan niin siinä se on - ja sitten vain kopiointi, talletus ja perääntyminen.
 

- joskus taas alat kaivata sitä pöhköksi editoitua. Sekin löytyy arkistosta ja sen arkistointinumero niitä suurinpia.
- dokumenttien kanssa on samankaltainen järjestely, niiden ajaminen kyllä päätyy vain editointiin.
- toiminta on pakko tehdä näin, mitään automaatteja ei voi tehdä. Sillä vaikka ne toimisivatkin ensimmäisellä kerralla niin ne tekisivät sen että jotain katoaisi; yleensä merkityksetöntä mutta joskus merkityksellistä.
Laita seuraava koodi paikkoihin: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, näppäinversio/geditin ja päätteen asetukset   ja: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, hiiriversio/geditin ja päätteen asetukset
Koodia: [Valitse]
Teoriassa gedit lopetaan painamalla CTRL-q tai: tiedosto-quit , mutta käytännössä voit lopettaa geditin myös sulkemalla geditin ikkunan.

Tehtäessä skriptiajurilla geditin alaisuudessa runsaammin skriptejä voit editoidessasi skriptejä lisätä editointi-ikkunaan haluamasi tiedoston sisällön omalle sivulleen painamalla nappulaa f2 kun teet seuraavat asetukset: näpäytä geditissä: muokkaa - asetukset - liitännäiset - ruksi kohtaan "ulkoiset työkalut" - sulje - työkalut - Manage external tools - laajenna ikkuna ja siirrä keskipalkkkia jotta näet sanat kokonaan - näpäytä vasemmassa ikkunassa kohtaa "Suorita komento"-näpäytä hiiriosoitin kohtaan "lyhytvalinta näppäin" - paina esimerkiksi nappulaa f2-kirjoita skriptin teksti ikkunaan nimeltään Muokkaa ja lopuksi paina : Sulje
skriptin teksti voi olla esimerkiksi:
#!/bin/sh
gedit polku/tiedosto         (minulla se on tällähetkellä: gedit ~/OMATSKRIPTIT/OHJEITA/matriisi ~/OMATSKRIPTIT/OHJEITA/merkkijono

Samoin saattaa kannattaa määritellä gedit näyttämään rivinumerot: mene geditiin ja näpyttele: Muokkaa-Asetukset/laita ruksi neliöön kohdalla: Näytä rivinumerot-sulje
- nämä ovat samat rivinumerot joihin virhe-ilmoitukset viittaavat.
- tekstien rivit on numeroitu aina: gedit vain määrätään näyttämään ne.

geditiin kannattaa tehdä myös asetus: muokkaa-Asetukset/laita ruksi neliöön kohdalla: korosta vastaavat sulut

geditiin kannattaa tehdä myös asetus: muokkaa-asetuksetliitännäiset/laita ruksi neliöön kohdalla: pika-avaus

päätteessä kannattaa tehdä asetus: muokkaa-profiilit-editoi ja laita ruksi kohtaan: "Use custom terminal size" - 240 saraketta 80 riviä ja: Vieritys-rajoittamaton

- kun geditissä siirtää hiiriosoittimen osoittamaan jotain välilehteä tulee hiiriosoittimen tekstiin välilehdellä editoitavana olevan tiedoston täydellinen polku.
- geditillä on paljon muitakin ominaisuuksia, esimerkiksi tiedostoselain jonka navulla voi liittää halutun tekstin omalle sivulleen, äskenkäytettyjen lista ... ________________________________________________________________________________________________________________________________________________________________________________
gedit:illä on kaksi toimintamuotoa ja Skriptiajurissa käytetään seuraavaa: kun Skriptiajuri syöttää sivun Geditiin niin Gedit sallii Skriptiajurin jatkaa taustaajona ottaen näytön ja näppäimistön hallintaansa. Tällöin Skriptiajuri voi siellä taustalla toimiessaan syöttää Gedit:iin uusia sivuja. Mutta mikäli IDE:ssä siellä taustalla käytetään jotain geditiin syötettyä sivua niin käyttö koskeekin sitä editoimatonta versiota kunnes gedit lopettaa. Siis siinävaiheessa kun geditiin on syötetty kaikki sivut täytyykin IDE siellä taustalla seisauttaa esimerkiksi read-lauseeseen mikäli se käyttää jotain gedit:iin syötettyä sivua. Siellä taustalla IDE sitten jää odottamaan kunnes se saa näppäimistöltä jotakin jonka se voi saada vasta sitten kun gedit lopetetaan ja IDE palaa edusta-ajoksi ja saa näppäimet. IDE:n virtuaalinäytön teksti kopioidaan myös fyysiselle näytölle kun IDE palaa edusta-ajoksi.

Mikäli geditiin syötettyä tekstiä on muutettu niin IDE voi "painaa itse näppäintä" ja toiminta jatkuu automaattisesti. Vain jos tekstiä ei ole muutettu joutuu sitä näppäintä painamaan ihan fyysisesti.
Talleta seuraava teksti paikkaan : ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, näppäinversio/nappulatekniikkaa
Koodia: [Valitse]
Näppäinversion nappulatekniikka: kun IDE käynnistetään avautuu melko normaali tiedostopuu.
 ____________________________________________________________________________________________________________________________________
|  enter=suorita        f2=koodaa, f4=dokumentoi, end=erikoistoimet, home=näytä ohjeet             17.19.2012 13:27  koodeja: 6      |
|  ollaan kansiossa:omatskriptit                                                                                                     |
|                                                                                                                                    |
|  .edellinen_kansio. broken-link.sh     ex10.sh            ex45.sh            exercising-dd.sh   bashnumbers.sh     redir3.sh       |
|  ARKISTO            brownian.sh        ex11.sh            ex46.sh            factr.sh           online.sh          redir4a.sh      |  
|  HTML               bubble.sh          ex12.sh            ex47.sh            fc4upd.sh          opprec-table.sgml  redir4.sh       |
|  anon.sh            ex13.sh            ex48.sh            fetch_address-2.sh ip.sh              pad.sh             redir5.sh       |    
|  abs-book.sgml      cards.sh           ex14.sh            ex49.sh            fetch_address.sh   isalpha.sh         ref-params.sh   |      
|  add-drive.sh       case4.sh           ex15.sh            ex4.sh             fibo.sh            iscan.sh           remote.bash     |      
|  agram2.sh          case-cmd.sh        ex16.sh            ex50.sh            fifo.sh            is_spammer.bash    reply.sh        |        
|  agram.sh           cdll               ex17.sh            ex51.sh            fifteen.sh         is-spammer.sh      resistor        |        
|  alias.sh           Change.log         ex18.sh            ex52.sh            file-comparison.sh keypress.sh        restrict        |          
|  allprofs.sh        collatz.sh         ex19.sh            ex53.sh            file-info.sh       kill-byname.sh     return-t        |          
|  alt-bc.sh          colm.sh            ex1a.sh            ex54.sh            file-integrity.sh  kill-process.sh    revpospa        |            _____________________________________________________________________________________________________________________________________  

 
- tiedostopuussa liikutaan niinkuin normaalistikin kun liikutaan ilman hiirtä: nuolinäppäimillä ja enterillä. IDE:ssä vain toimii myös
 vasemmalle- ja oikealle nuolet.
                
- kaksi ylintä riviä on otsikkoja, loput sivusta on näkymää tiedostopuuhun.

- näytön ylimmällä rivillä oikealla lukee: <skriptin tekoaika>    koodeja: <luku> joka kertoo montako kertaa skriptiä on editoitu.
 Sillä tehdäänpä skriptiin kuinka pieni muutos tahansa niin skriptistä tehdään uusi versio eikä minkään tiedon anneta tuhoutua.
 Ei skriptit vie sittenkää kovalevytilaa juuri ollenkaan.

- valittavien joukossa  ensimmäinen valittava on .edellinen_kansio. . Jos se on valittuna kun painetaan enter niin siirrytään alemmalle kansiotasolle.

- seuraavina valittavina ovat kansiot ja ne on aina kirjoitettu suurilla kirjaimilla. Jos joku niistä on valittuna kun painetaan enter niin siirrytään sennimiseen kansioon.

- seuraavina valittavina ovat tiedostot ja niiden nimet ovat yleensä kirjoitettu pienillä kirjaimilla.jos niiden kohdalla painetaan enter niin ensin tarkistetaan onko niissä oleva teksti käännös-kelpoinen BASH-skripti ja jos on, niin se laitetaan suoritukseen, jos ei niin sen koodi viedään editoriin käännös-virheiden kanssa. Jos valittu ei ole käännöskelpoinen mutta se on skripti niin sen teksti viedään editoriin ilman listaa käännös-virheistä.

- ei kansioiden eikä nimien pituutta eikä merkkivalikoimaa ole rajoitettu. Silloin näytössä ei ole sarakkeita tai niitä on  ainakin vähemmän.

- editoriin päästään myös painamalla f2 ja tällöinkin mikäli kyse on skriptistä niin erilliselle lehdelle viedään ne virhevistit mitkä syntyisivät käännöksestä.

- editoriin päästään myös painamalla f4, mutta tällöin editoriin ei viedäkään tiedostoa vaan sen dokumentti.

- nappia end painamalla päästään erikois-toimintoihin.

- kun nappia home (=ohjeita) painetaan niin jokainen tiedosto joka on OHJEITA-kansiossa luetaan gedit:n omalle sivulle. Siten kaikkia ohjeita voi editoida (itseasiassa se on suositeltavaa), uusiin ongelmiin voi tehdä uusia sivuja tai poistaa vanhoja sivuja: uudet ohjesivut ilmestyvät geditiin omille lehdilleen automaattisesti ja poistuvat kun niiden sisällöksi kirjoitetaan tyhjää. Myös ohjeista löytyy arkistosta kaikki vanhat versiot. Uuden lehden saat kun talletat jonkun vanhan uudelle nimellä ja editoit sen uuden sivun - talletus ei muuten tuhoa vanhaa vaan siirtää sen vain arkistoon.



Editorin ikkunassa otsikkorivillä on ensimmäisenä tiedoston nimi - sillä sivulla on tiedoston teksti.

Sen perässä on numeroituja lehtiä - ne on noudettu arkistosta ja ne ovat tekstin tuoreimmat versiot ja mitä suurempi numero sitä tuoreempi. Suurin numero on sama kui teksti - siis tekstiä voi rauhassa editoida koska alkuperäinen versio löytyy vierestä.

Näiden lehtien perässä saattaa olla lehti nimeltä virhe  ja se ilmestyy vain kun teksti on skripti jossa tulkin kertomat käännösvirheet.

Näiden lehtien perään tulevat lehdet jotka noudetaan erikseen asimerkiksi Avaus-toiminteella - ne voivat esimerkTeoriassa gedit lopetaan painamalla CTRL-q tai: tiedosto-quit , mutta käytännössä voit lopettaa geditin myös sulkemalla geditin ikkunan.


geditiin kannattaa tehdä myös asetus: muokkaa-Asetukset/laita ruksi neliöön kohdalla: korosta vastaavat sulut

geditiin kannattaa tehdä myös asetus: muokkaa-asetuksetliitännäiset/laita ruksi neliöön kohdalla: pika-avaus

päätteessä kannattaa tehdä asetus: muokkaa-profiilit-editoi ja laita ruksi kohtaan: "Use custom terminal size" - 240 saraketta 80 riviä ja: Vieritys-rajoittamaton

- kun geditissä siirtää hiiriosoittimen osoittamaan jotain välilehteä tulee hiiriosoittimen tekstiin välilehdellä editoitavana olevan tiedoston täydellinen polku.
- geditillä on paljon muitakin ominaisuuksia, esimerkiksi tiedostoselain jonka navulla voi liittää halutun tekstin omalle sivulleen, äskenkäytettyjen lista ... ________________________________________________________________________________________________________________________________________________________________________________
gedit:illä on kaksi toimintamuotoa ja IDE:ssä käytetään seuraavaa: kun IDE syöttää sivun Geditiin niin Gedit sallii IDE:n jatkaa taustaajona ottaen näytön ja näppäimistön hallintaansa. Tällöin IDE voi siellä taustalla toimiessaan syöttää Gedit:iin uusia sivuja. Mutta mikäli IDE:ssä siellä taustalla käytetään jotain geditiin syötettyä sivua niin käyttö koskeekin sitä editoimatonta versiota kunnes gedit lopettaa. Siis siinävaiheessa kun geditiin on syötetty kaikki sivut täytyykin IDE siellä taustalla seisauttaa esimerkiksi read-lauseeseen mikäli se käyttää jotain gedit:iin syötettyä sivua. Siellä taustalla IDE sitten jää odottamaan kunnes se saa näppäimistöltä jotakin jonka se voi saada vasta sitten kun gedit lopetetaan ja IDE palaa edusta-ajoksi ja saa näppäimet. IDE:n virtuaalinäytön teksti kopioidaan myös fyysiselle näytölle kun IDE palaa edusta-ajoksi.

Mikäli geditiin syötettyä tekstiä on muutettu niin IDE voi "painaa itse näppäintä" ja toiminta jatkuu automaattisesti. Vain jos tekstiä ei ole muutettu joutuu sitä näppäintä painamaan ihan fyysisesti.

 
« Viimeksi muokattu: 10.03.13 - klo:15.12 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #6 : 21.05.11 - klo:05.36 »
BASH on ohjelmoinnin kannalta inhottava koska kehittäjät ovat sen inhottavaan tilaan jättäneet - tosin BASH:ista ei saa yleiseen ohjelmointiin kepaavaa mitenkään mutta  prototyyppien tekemisessä se on verraton.
Jokainen tietokoneita käyttävä osaa BASH:ia luonnostaan. Tämä luo harhakuvan siitä että BASH olisi helppo ohjelmointikieli. Itseasiassa BASH on niin vaikea käyttää, että skriptaus perustuu täysin kopiointiin - muuten kirjastot ovat kopiointi-automaatteja joten kaikki ohjelmointikielet perustuvat kopiointiin. Sillä itse tekemäsi koodi on kääpiö kirjastojen rinnalla.

BASH:issa on ohjelmoinnin kannalta kaksi puutetta ja ne molemmat on osittain ratkaistu:
- kehitysympäristönä toimii tekstinkäsittelijä eikä sillä pysty tekemään kunnollista versionhallintaa tai kunnollisia hakutoimintoja jotka ymmärtävät BASH-koodia.
- kirjastot puuttuvat. BASH tuntee kyllä kirjastot, ja mikäli BASH:illa koodaa on niitä pakko tehdä itse sillä kirjastot ovat kaikkien ohjelmien perusta. Koetapas ohjelmoida C:llä käyttämättä kirjastoja.
« Viimeksi muokattu: 13.07.14 - klo:20.22 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #7 : 11.06.11 - klo:16.33 »
Laita seuraava koodi paikkoihin: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, näppäinversio/uudet käskyt   ja: ~/OMATSKRIPTIT/OHJEITA/Skriptiajuri, hiiriversio/uudet käskyt
Koodia: [Valitse]
- Valinnasta on kaksi versiota: näppäinversio ja hiiriversio.
  1. näppäinversion valintafunktiot ovat paikassa: http://forum.ubuntu-fi.org/index.php?topic=44605.msg296419#msg296419
  2. hiiriversion valintafunktiot ovat paikassa: http://forum.ubuntu-fi.org/index.php?topic=44605.msg295198#msg295198
- lisää skriptiisi valintafunktiot joko kopioimalla ne skriptiisi tai kirjoittamalla skriptisi alkuun rivi:
  . sen_tiedoston_nimi_ johon_olet_valintafunktiot_laittanut  (ensimmäinen merkki on piste)

- lisää skriptiisi valittavat Valittavat-matriisiin esimerkiksi:
  Valittavat=(1 2 3 4 5 kukko kana piiroisen_pässi "mikäli valittavassa on välilyöntejä täytyy se laittaa heittomerkkien väliin")
  tai:  Valittavat=({mistäluvusta..mihinlukuun..askel_jos_tarvitaan})
  tai:  Valittavat=$(tiedostolistaus "$Kansio") # käyttäen valikkohiirelle ja valikkonäppäimille kirjastojen funktiota
  tai kurki tekotapa ohjeesta ohjeet/matriisi minkä ohje toimii kaikille käskyille.
- lisää skriptiisi Valittavien muodostamisen jälkeen kutsu: ValitseValittavistaYksi "ohjerivi jos haluat määritellä sellaisen" "avaimet
  jos haluat määritellä niitä"
  avaimet määritellään tyyliin: "f2=tee uutta, f3=hävitä vanhaa ..."  . Tunnetut avaimet: insert, delete, end, home, f1, f2, f3, tai f4
                                                                                                                                             
  Palautusarvot ja huomautukset:
- skripti palauttaa valitun rivin tekstin muuttujassa ValitunTeksti ja järjestysnumeron muuttujassa ValitunNumero.
- skripti palauttaa myös muuttujan Tapahtuma jolla on arvona sen avaimen nimi jota on painettu valinnan suorittamiseksi.
- skripti palauttaa myös kutsussa olleen ohjerivin CRC32:n muuttujassa crc. CRC on 32-numeroinen ja se yksilöi ohjerivin hyvin.
- noiden perustoimintojen lisäksi toimintaa voi säätää tilanteeseen sopivaksi:
- jos et halua määritellä otsikkoa niin jonkinlainen otsikko muodostetaan automaattisesti. Otsikkorivi on rivi 2.
- skriptissä voidaan kutsua valikkoa monta kertaa vaihtaen välillä Valittavat
                                                                                                                                     
- Välillä eteen tulee tehtäviä, joiden suorittajista jotkut ovat ammattilaisia ja jotkut ei-ammattilaisia. Esimerkiksi kun koneen paketti-
  varastot halutaan tyhjentää niin ammattilainen antaa käskyn: "sudo apt-get clean" koska sen kone ymmärtää, mutta ei-ammattilainen ei saa
  sitä pakettivarastoa tyhjennettyä koskei tuommoista käskyä tiedä olevankaan. Mutta kumpikin osaa käskeä: "tyhjennä pakettivarasto" ja
  sitten ohjelma suorittaa koodimuunnoksen muotoon: sudo apt-get clean. Tämä koodimuunnos tapahtuu valinnan yhteydessä: matriisissa
  Valittavat on selväkieliset käskyt ja matriisissa ValitunArvo on vastaavana jäsenenä se koodimuunnettu. Matriisin ValitunArvo voi jättää
  määrittelemättä jos ei siitä katso olevan mitään hyötyä tai määritellä se osittain tai paloittain, esimerkiksi: ValitunArvo=({1..20..2})

                                                                                                                                                 
Sitten valikko-ohjelman rajoituksista:
- valittavat esitetään aina yhdellä sivulla. Ohjelma käyttää koko näyttöä. Mikäli valittavia on useampia kuin näyttöriveille mahtuu aletaan
  valittavia jakaa sarakkeisiin; sarakkeenpituus määräytyy automaattisesti
- hyödyllinen rajoitus: samaa kohtaa ei voi valita useampaa kertaa peränjälkeen painamatta välillä jotain nuoli-näppäimistä
- yleensä päätteen ohjeen pika-valinta on f12. Joskus se kuitenkin on f1 jolloin se täytyy vaihtaa - helpointa on olla käyttämättä f1:tä
                           
« Viimeksi muokattu: 28.07.13 - klo:14.59 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #8 : 14.06.11 - klo:18.30 »
Skriptinteossa debuggaaminen on työläämpää kuin skriptinteko. Voi syystä asettaa koko debuggaamisen mielekkyyden kyseenalaiseksi: tavallaan siinä huonompi yrittää korjata parempaansa.

Kun skripti tekee jotain muuta kuin ohjelmoija tarkoittaa on hyvä voida tarkistaa missä vaiheessa toiminta alkaa mennä metsään. Xref_funktiot antaakin mahdollisuuden tulostaa skriptin muuttujien nimet, arvot, osoitteet ja tyypit(=muuttuja, jonomuuttuja tai matriisi). Myös muuttujaa vastava declare-lause tulostetaan mikäli sellainen löytyy. Siitä selviää mahdolliset lisämääreet: 'r=vain luettavaksi', 'i=vain kokonaisluku-muuttujille', 'a=tavallinen matriisi', 'A=assosiatiivinen matriisi', 'f=funktion nimi', 'F=tulosta funktion nimi ja sisältö' ja 'x=valmistele muuttuja EXPORT:tia varten'. Mikäli skriptissä on funktioita tulostetaan myös niiden funktiomäärittelyt (=ensimmäinen rivi).

BASH:in matriisin osoitteiden ei tarvitse alkaa nollilta eikä matriisin osoitteiden täydy olla perättäisiä - ja assosiatiivisessa matriisissa 'osoite' voi olla tekstiäkin. Xref tulostaakin muuttujien arvojen lisäksi myös osoitteet mikäli osoitteita on.

Mikäli matriisissa on vain yksi jäsen ja sen osoite on nolla niin sitä ei aina erota tavallisesta muuttujasta. Tulostettaessa on ihan sama määrääkö: echo $Muuttuja   tai: echo ${Muuttuja[0]} . Käyttämisessä niillä on eroja.

Määrittelemätön matriisi ei eroa määrittelemättömästä muuttujasta muuten kuin ohjelmalistauksessa saattaa olla declare-lause.

Kirjoittamaton sääntö on, että käyttöjärjestelmän muuttujien nimissä kaikki aakkoset ovat suuria. Itse tehtyjen muuttujien nimet eivät koskaan saa olla kirjoitettu pelkästään suurilla kirjaimilla vaan niistä tulee löytyä ainakin yksi pieni kirjain jotta Xref löytäisi ne. Yksimerkkiset muuttujanimet kuitenkin hyväksytään vaikka ne olisikin kirjoitettu suurella ja perässäkin voi haluttaessa olla numerot 0-9. Mutta niiden tulostuksessa saattaa olla kummallisuuksia.

Matriisi ja merkkijono jossa on välilyöntejä voivat tulostua samallatavoin.

Mikäli muuttujan arvossa on yksikin välilyönti tulee muuttuja laittaa lainaus-merkkien väliin.
- välilyöntejä on muuten toisentyyppinenkin: alt-gr-<välilyönti>. Tulostettaessa se on kuin normaali välilyönti, mutta sitä käsitellään niinkuin normaalia kirjainta. Tällaista "non-breakable"-välilyöntiä ei tarvitse laittaa lainaus-merkkien väliin.

Assosiatiivisen matriisin osoitteet voivat olla tekstiäkin mutta jos osoitteen tekstin laittaa lainaus-merkkien väliin tulevat lainausmerkit osoitteen osaksi. Muuten assosiatiivisen matriisin järjestys saattaa muuttua tulostettaessa sikäli kuin järjestyksellä väliä onkaan.
 
Jottet halutessasi käyttää skripteissäsi komentoa:tulostamuuttujat joutuisi kirjoittamaan funktioita erikseen jokaiseen skriptiin, voit kirjoittaa funktiomäärittelyt kerran kirjastoon ja kutsua ne skripteissäsi käyttöön lisäämällä skriptiesi alkuun lauseen: . /home/$(whoami)/omatskriptit/FUNKTIOKIRJASTO/Xref_funktiot
- rivin tulee siis alkaa pisteellä.

Kopioi kansioon ~/omatskriptit/FUNKTIOKIRJASTO seuraavat määrittelyt tiedostoon nimeltään: Xref_funktiot :

Koodia: [Valitse]
#!/bin/bash  
# petteriIII 21.2.2013
# Xref-ohjelma tulostaa muuttujien arvot mikäli niiden nimessä on ainakin yksi pieni kirjain tai kun niiden nimi on alle kaksi merkkiä pitkä.

# muutujien määrittelyssä ei lueta ohjelmalistausta muissa tarkoituksissa kuin:
# - luetaan declare-lauseet ja tulostetaan ne sellaisinaan mutta vaikka ne olisivat ristiriitaisia tulostuksen kanssa niin niitä ei käytetä.
#   declare-lauseitahan ei tarvitse olla ja mikäli se on ristiriidassa tulosteen kanssa on se todennäköisemmin väärä.
# - luetaan ja tulostetaan funktiokutsut.

function Xref () {
function TulostaMuuttuja () {
[[ $(eval echo \$$1) ]] && echo -n $1' on numero- tai tekstimuuttuja arvoltaan: ' && eval echo \$$1 || echo $1" on määrittelemätön"
}

function TulostaTekstijono () {
[[ $(eval echo \$$1) ]] && echo -n $1' on jono-muuttuja arvoltaan: ' && eval echo \$$1 || echo $1" on määrittelemätön"
}

function TulostaMatriisi () {
echo $1' on matriisi.'
[[ $(eval echo \${$1[*]}) ]] && {
echo -n 'arvot    : '; eval echo \${$1[*]}   # arvojen väliin tulostuu välilyönti
echo -n 'osoitteet: '; eval echo \${!$1[*]}  # osoitteiden väliin tulostuu välilyönti
} || echo $1" on määrittelemätön"
}

function TestaaMuuttuja () {
MUUTTUJAN_OSOITTEET=$(eval echo \${!$1[*]})
[[ $(echo $MUUTTUJAN_OSOITTEET | grep " ") ]] && TulostaMatriisi $1 || {
MUUTTUJAN_ARVOT=$(eval echo \$$1)
[[ $(echo $MUUTTUJAN_ARVOT | grep " ") ]] && TulostaTekstijono $1 || TulostaMuuttuja $1
}
# $BASH_SOURCE ->  ${0}  = skriptiä kutsuneen nimi      
cat "${0}" | grep "declare".*" $1$"
cat "${0}" | grep "declare".*" $1 ".*"#"
cat "${0}" | grep "declare".*" $1="
echo
}

# function Xref () {
echo -e "Xrefiä on kutsuttu skriptistä:"${0}".   Kutsu tehtiin riviltä:"${BASH_LINENO[0]}"\n\n"
declare > /tmp/delme
for RIVI_DECLARE_LISTASSA in $(cat /tmp/delme)  
do
  [[ $RIVI_DECLARE_LISTASSA = TestaaMuuttuja ]] && break              
  [[ ! $RIVI_DECLARE_LISTASSA = *[\=]* ]] && continue                     # jos rivillä ei ole yhtäkuinmerkkiä niin rivin voi ohittaa
  [[ ${RIVI_DECLARE_LISTASSA:0:1} = \$ ]] && continue                     # tavallisesti muuttuja ei voi alkaa merkillä $.
  MUUTTUJAN_NIMI=$(echo ${RIVI_DECLARE_LISTASSA%%=*})                     # muuttujan nimeksi tulee merkit ennen yhtäkuinmerkkiä
  [[ $MUUTTUJAN_NIMI = *[[:lower:]]* ]] && TestaaMuuttuja $MUUTTUJAN_NIMI # jos muuttujanimestä löytyy yksikin pieni aakkonen niin Xref hyväksyy sen
  [[ $MUUTTUJAN_NIMI = [A-Z] ]] && TestaaMuuttuja $MUUTTUJAN_NIMI         # isolla kirjoitetut yksimerkkiset muuttujanimet hyväksytään
  [[ $MUUTTUJAN_NIMI = [A-Z][0-9] ]] && TestaaMuuttuja $MUUTTUJAN_NIMI    # [0-9] toistetaan niin monta kertaa kuin sallitaan nimessä olevan numeroita
done
rm /tmp/delme

APU=$(cat "${0}" | grep function | grep -v Xref | grep -v TulostaTekstijono | grep -v TulostaMatriisi | grep -v TestaaMuuttuja | grep -v TulostaMuuttuja)
[[ $APU > 0 ]] && echo "listaus skriptin funktioista:" &&  echo -e ' '"${APU[@]/%/\n}"  
}  
« Viimeksi muokattu: 22.09.13 - klo:13.40 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #9 : 28.07.11 - klo:12.37 »
BASH:in read-käskyyn saa kyllä mahdollisuuden editointiin jos vai muistaa ottaa sen käyttöön. Mutta historiaa se ei tunne. Lisäsin Valikko_funktioihin käskyn luenappis joka toimii kuten käsky read, mutta siinä on sekä editointi-mahdollisuus että historia. Esimerkki sen käytöstä:

Koodia: [Valitse]
#!/bin/bash

. /home/$(whoami)/omatskriptit/FUNKTIOKIRJASTO/Valikko_funktiot

# pääohjelma
luenappis luku 'Kirjoitapa luku:' # siis tuo luku on se jota luetaan. Viestiä ( 'Kirjoitapa luku:' ) ei tarvitse kirjoittaa.
echo 'tänne tuli luku: '$luku     # luku voi olla tekstiäkin tai merkkijono.
read -p 'paina enter jatkaakseesi'

- tosiaan; Valikko_funktioiden koodi on kohdassa: http://forum.ubuntu-fi.org/index.php?topic=303.msg288767#msg288767
« Viimeksi muokattu: 19.04.12 - klo:19.57 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #10 : 03.09.11 - klo:05.47 »
Kaikki ihmisen tekemä on "valettu" jossakin muotissa. Linuxissa tämän muotin nimi on "regular expression" elikä regex. Esimerkiksi päivämäärät tehdään muotissa jonka regex on: [0123][0-9].[01][0-9].[20][0-9][0-9][0-9]  (siis: pp.kk.vvvv). Kun halutaan tulostaa pitkästä dokumentista siinä olevat päiväykset tulostetaan dokumentti läpi "päivämäärä muotista"  ja kaikki mikä sopii tuohon muottiin tulostetaan sillä ne ovat päivämääriä.

- tarkan muotin tekeminen on vaikeaa vähänkin monimutkaisissa tapauksissa ja se onkin kokeellista hommaa ja teoriat vain kertovat mitä kannattaa kokeilla ja minkä pitäisi toimia. Sitäpaitsi en ole vielä nähnyt ohjetta joka ei olisi täynnä kirjoitusvirheitä ja jopa loogisiavirheitä - niitä on ilmanmuuta tässäkin.
- edellinen haku awk:illa: awk 'BEGIN {muotti="[0123]?[0-9].[01]?[0-9].[20][0-9][0-9]" }; $0 ~ muotti { print }' ~/ohje
- vaikka muottia yleensä käytetään grep, awk ja sed ohjelmien välityksellä toimivat ne yleensä itse BASH:issakin:
  pvm="31.12.2014"; echo ${pvm//[0123][0-9].[01][0-9].[20][0-9][0-9][0-9]/tämä on suomalainen paivays}
- bashissa on operattori =~ joka toimii jotenkin regex:ienkin kanssa. Sen käyttö: [[ $tekstijono =~ regex ]] && toiminto
  käsky =~ asettaa muuttujia: BASH_REMATCH koko regexistä ja BASH_REMATCH[n] regex:in jokaisen sulun järjestysluvun mukaan.

Koodia: [Valitse]
*         muotti kuvaa mielivaltaista määrää sen edessä olevia merkkejä. Siis a* vastaa joukkoa a-merkkejä ja a.* mielivaltaista merkkijoukkoa jonka edessä on a
+         kuten *, mutta joukko ei voi olla tyhjä vaan ainakin yksi merkki.  esim | grep -P ab+c => muotti sopii kun sana alkaa a ja loppuu c ja välissä yksi tai monta b:tä
-         joukon muodostaja ellei se ole ensimmäinen tai viimeinen merkki; tai jos sitä ei edellä \ 
?         kuten *, mutta joukko on vain yksi tai nolla merkkiä. Esim. grep -P ab?c sopii ac tai abc
                                                                      sed -re 's/ab?c/d/g' muuttaa sanat ac tai abc sanaksi adc             
.         muotti kuvaa yhden mielivaltaisen merkin, mukaanlukien rivinsiirron
[...]     merkkiryhmän ympärille laitetaan hakasulut
\|        sanojen väliin laitetaan \| ja hakasulkuja ei saa olla  (=or-toiminto, sed:issä toimii sellaisenaan mutta grep vaatii kytkintä -E tai voi käyttää suoraan egrep:iä)

^         ankkuroi haun rivin alkuun; huomaa että välilyönti lasketaan mukaan. Merkin ^ tulee olla hakutermissä ensimmäisenä   
$         ankkuroi haun rivin loppuun. $ pitää olla hakutermissä viimeisenä
\b        ankkuroi muotin sananojen alkuun, loppuun tai rivin alkuun tai rivin loppuun.
\B        ankkuroi muotin sananojen alkuun tai loppuun -> siis sana ennen on välilyönti ja niin perässäkin
\w        etsii konaisia sanoja
\W        kokonaiset sanat ei kelpaa?
\s        muotti alkaa "whitespace":lla
- ankkurit sopii sed:iin sellaisenaaan mutta grep vaatii ympäröimään ne lainausmerkeillä

[abcd]               mikä hyvänsä merkki listassa
[^abcd]              mikä tahansa muu merkki kuin listassa oleva. Lista voidaan kasata joukkona, esim a-z
"\([a-z]\)\1"        muotti kuvaa kahteen peräkkäistä samaa pien-aakkosta. Näitä takaisinpäin viittauksia voi olla 9 - "takaisinpäinviitattava" alkaa aina \(
[muotti1\|muotti2]*  muotti kuvaa jokaiseen joka sopii muotti1:een tai muotti2:een.
muott1muotti2        muotti kuvaa jokaiseen joka sopii sekä muotti1:een että muotti2:een.; esim. [0-9][0-9] merkitsee: kaksi numeroa peräkkäin
- merkit $, *, ., [, and \ menettävät listassa erikoismerkityksensä. Kuitenkin
- ilmaisut muotoa [.ch.] ja [=a=] ovat erikseen. Myös merkinnät \n and \t tunnistetaan listoissa.
| grep -Po '(?<=edessä).*(?=perässä)'  # tulostaa tekstin joka on hakuavaimien välissä

| grep -Po 'tätä_haetaan(?=.*tämän_täytyy_olla_perässä_mutta_tätä_ei_valita)'  # välissä saa olla tekstiä; kirjoita sanojen paikalle ne jotka ovat käytössä
| grep -Po 'tätä_haetaan(?!tämä_ei_saa_olla_perässä)'                          # välissä ei saa olla tekstiä
| grep -Po '(?<=tämän_täytyy_olla_edessä_mutta_tätä_ei_valita)tätä_haetaan'    # välissä ei saa olla tekstiä
| grep -Po 'tätä_haetaan(?<!tämä_ei_saa_olla_edessä)'                          # välissä saa olla tekstiä

 
Merkkijoukot (merkkijoukkojen ympärille kirjoitetaaan yleensä toisetkin hakasulut, esim. [[:lower:]]. Jos tässä esimerkissä kyse olisikin merkkijoukosta
jossa ei saa olla yhtään pientä kirjainta merkitään se: [^[:lower:]]
[:alnum:] -> [A-Za-z0-9]
[:alpha:] -> [A-Za-z]
[:blank:] -> [ \t] välilyönti tai TAB
[:cntrl:] -> [\x00-\x1F\x7F] kontrollimerkit
[:digit:] -> [0-9] , [^0-9] -> kaikki muut kuin numerot
[:graph:] -> [\x21-\x7E] näkyvät merkit
[:lower:] -> [a-z] pienet kirjaimet
[:print:] -> [\x20-\x7E] näkyvät merkit ja välilyönti
[:punct:] -> [][!"#$%&'()*+,./:;<=>?@\^_`{|}~-]
[:space:] -> [ \t\r\n\v\f] Whitespace characters
[:upper:] -> [A-Z] suuret kirjaimet
[:xdigit:] -> [A-Fa-f0-9] hexadesimaalit
- merkkijoukot laitetaan yleensä kaksinkertaisiin sulkuihin, esim. echo a | grep [[:lower:]]


seuraavat kuuluvat "regularexpressionin" laajennoksiin; ne vaativat esimerkiksi egrep-ohjelmaa tai grep -E
{i\}      kuten *, mutta jokko on täsmälleem i-kappaletta
{i,j\}    kuten *, mutta lukumäärä on välillä i-j
{i,\}     kuten *, mutta jotakin yli i. siis esimerkiksi: egrep ^.\{15\}A etsii sanaa jonka alussa on 15 mielivaltaista merkkiä ja heti niiden perässä A
{,1\}     edellistä kohtaa on nolla tai yksi
a{2,\}?   jokainen a-ryhmä, jossa on vähintään 2 a:ta  (2:n paikalla voi olla mikähyvänsä luku joka toimii miniminä)
\(regexp\) esim. \(abc\)* korvaa nollaa tai suurempaa joukkoa jonka jokainen jäsen on abc, kuntaas abc* etsisi joukkoa jonka edessä on ab ja perässä on nolla tai useampi c

Siis toisin esitettynä:
a*b          # yksi tai useampi a ja perässä yksi b
a\?b         # joko b tai ab
a\+b\+       # rivi alkaa kahdellä tai useammalla a:lla ja perässä yksi tai useampi b.
.*           # rivillä voi olla mitätahansa     
^main.*(.*)  # rivi alkaa sanalla main ja rivillä on jossain merkit ()
^#           # rivi alkaa merkillä #
\\$          # rivi loppuu kenoon
\$           # rivi päättyy dollari-merkkiin
[a-zA-Z0-9]  # merkkijono jossa on pelkästään aakkosia ja numeroita
[^ tab]\+    # rivin alussa TAB ja sen perässä merkkijono
^\(.*\)\n\1$ # kaksi samanlaista tekstijonoa ja niiden välissä rivinvaihto
.\{9\}A$     # tekstijono jossa on yhdeksän merkkia ja sitten A rivin lopussa
^.\{15\}A    # tekstijono jonka alussa on 15 merkkiä ja sitten A

if [[ string =~ regex ]]; then tee_jotakin; fi
   
http://en.wikipedia.org/wiki/Regular_expression#Character_classes

seuraavat escape-koodatut tunnetaan:
\t tab
\n newline
\r return
\f form
\a alarm
\e escape
\033 octal
\x1B hex
\c[ control
\l lowercase
\u uppercase
\L lowercase
\U uppercase
\E end
\Q quote
\w Match a "word" character
\W Match a non-word character
\s Match a whitespace character
\S Match a non-whitespace character
\d Match a digit character
\D Match a non-digit character
\b word boundary
\B non-(word boundary)
\A beginning of string
\Z Match only at EOS, or before newline
\z Anchor Match only at end of string
\G Anchor Match only where previous m//g left off
« Viimeksi muokattu: 04.10.14 - klo:21.12 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #11 : 15.02.12 - klo:13.30 »
Yhdessä suhteessa pätevä ison sovelluksen laadun tarkistus on jättää sovellus välillä täysin rauhaan ja tehdä jotakin ihan muuta. Sitten paljon myöhemmin tarkistetaan toimiiko sovellus enää moitteetta ja saako sovelluksen nopeasti hallintaan korjauksien tekemistä varten. Tämä testi on nyt tehty skriptiajurille ja se toimi moitteetta. Esimerkiksi 12.04 ja unity vaativat koodi-muutoksia ja bugejakin tuli korjattua.    


Yksi ominaisuus tuli lisättyä skriptiajuriin (ominaisuus ei toimi kovin iäkkäillä Ubuntuilla):
Kun ajetaan skriptiä joka käyttää sellaista käskyä jonka koodia ei ole ladattu juuri siihen koneeseen mutta jonka koodi löytyy repoista niin käskyn koodi ladataan.
- käskyt löytyvät yleensä aivan toisen-nimisestä paketista kuin mikä nimi käskyllä on.
- toiminta ei vaadi skriptiin muutoksia silloinkaan kun skripti on tehty kauan sitten.
- tehdyt muutokset vain poistivat muutamia varoituksia. Toimintaan ne eivät siis vaikuttaneet.


Seuraavasta ohjeesta saa periaatteen kuinka geditiin lisätään ulkoisia komentoja:
Tehtäessä skriptiajurilla geditin alaisuudessa runsaammin skriptejä voit editoidessasi skriptejä lisätä editointi-ikkunaan haluamasi tiedoston sisällön omalle sivulleen painamalla nappulaa f2 kun teet seuraavat asetukset: näpäytä geditissä:muokkaa-asetukset-liitännäiset-ruksi kohtaan "ulkoiset työkalut"-sulje-työkalut-Manage external tools-LAAJENNA IKKUNA JA SIIRRÄ KESKIPALKKIA JOTTA NÄET SANAT KOKONAAN-näpäytä vasemmassa ikkunassa kohtaa "Suorita komento"-näpäytä hiiriosoitin kohtaan "lyhytvalinta näppäin"-paina nappulaa f2-kirjoita skripti ikkunaan nimeltään Muokkaa ja lopuksi paina : Sulje
skriptin teksti voi olla esimerkiksi:
!/bin/bash
gedit polku/tiedosto         (minulla se on tällähetkellä: ~/omatskriptit/OHJEET/matriisi ~/omatskriptit/OHJEET/merkkijono ~/omatskriptit/OHJEET/matematiikka)


Samoin saattaa kannattaa määritellä gedit näyttämään rivinumerot mikäli koodaa paljon: mene geditiin ja näpyttele: Muokkaa-Asetukset/laita ruksi neliöön kohdalla: Näytä rivinumerot-sulje
- nämä ovat samat rivinumerot joihin virhe-ilmoitukset viittaavat.
- skriptien rivit on numeroitu aina: tämä on vain asetus siitä näytetäänkö ne.

Jos haluat aloittaa uuden ilmentymän skriptiajurista selataksesi toisella ohjeita ja samalla kun ensimmäisellä teet uutta skriptiä niin avaa ensimmäisen skriptiajurin ilmentymä normaalisti. Valitse sitten uusi työtila Dashboardin työtilan-vaihtimella ja paina uuden työtilan skriptiajuri-kuvaketta (jos painat Dashboard:n skriptiajurin kuvaketta palaataan ensin alkuperäiseen työtilaan).
- toiminta on tälläista vain 12.04:ssä. 11.10:ssä toimii hieman toisellatavalla ja ontuu sittenkin.
- samallatavoin voi avata vaikka kaksi aitoa firefoxia tai muita ohjelmia jotka eivät hyväksy toisiaan.
- siis myös työpöydälle pitää tehdä ohjelmalle kuvake.
-- koko asia esitettynä toisella tavalla: Dashboardin kuvake viittaa aina työtilaan 1, mutta kunkin työtilan oma kuvake viittaa omaan työtilaansa.

Olen jatkuvasti puhunut siitä että netin ohjeet ovat vanhentuneita. Niistä saa kammottavan ja *** tahallisesti !!!*** vääristellyn kuvan skriptauksesta. Esimerkiksi todellisuudessa BASH:in tekstin-käsittelyn pienet funktiot ovat poikkeuksellisen käteviä vaikka ohjeissa vakuutetaan niiden huonoutta.
Esimerkiksi tekstijonosta piti monimutkaisien valintojen perusteella ottaa palanen alusta, palanen keskeltä ja palanen lopusta. BASH-skriptinä helpohko yksinrivinen lause mutta muilla kielillä pitkä ja monia lauseita vaativa tehtävä. Koska olin uskonut virallisia vakuutteluja tein homman ensiksi todella vaikeasti, siihen kului karmeasti aikaa eikä se edes toiminut kunnolla.
« Viimeksi muokattu: 06.03.12 - klo:09.38 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #12 : 05.04.12 - klo:09.18 »
Komentorivin käytön yksi este on se, että komennot ovat pitkiä mikäli hyödyntää komento-kytkimiä, tiedostopuuta ja pitkiä nimiä. Ongelman ratkaisu on ennakoiva tekstinsyöttö.

Jokainen antamasi käsky viedään koti-kansion tiedostoon nimeltä .bash_history. Sitä voi selailla nuolinäppäimillä ja kun painaa esiintulleen kohdalla ENTER niin se suoritetaan. Mutta sitä voi käyttää paremminkin:
 
näppäile: !kap
- painettaessa ENTER suoritetaan ensimmäinen käsky historian lopusta alkuunpäin mennessä joka alkaa: kap

näppäile: !?näppi
- painettaessa ENTER suoritetaan ensimmäinen käsky historian lopusta alkuunpäin mennessä jossa jossain kohtaa on: näppi


- jos ominaisuuksia ei ole aikaisemmin käyttänyt niin ne ovat vähän arvaamattomia sillä ne toteutetaan välittömästi. Alkuunsa voi varmistua mihin ne viittaavat   painamalla ensin CTRL-r ja näppäilemällä sitten sen tekstin.
- hakusanassa voi olla kirjaimia vaikka kuinkamonta ja välilyöntejä voi olla vaikka kuinkamonta.
- historiasta tulee jatkuvasti käyttökelpoisempi mitä enemmän konetta käyttää. Tosin kannattaa tehdä muutos päätteen asetuksiin: avaa pääte - muokkaa - Profiilit - Muokkaa - Vieritys - ruksi laatikkoon: rajoittamaton. Tai kirjoita tiedostoon: ~/.bahrc rivi: unset HISTFILESIZE

- kun annat käskyjä niin historia-tiedostoon tulee aina uusi merkintä ja siis miljoonassa paikassa historiatiedostoasi on esimerkiksi käsky: sudo su
Tämänvuoksi historian selaamisesta tulee hidasta. Voitkin määrätä että jokakerran kun historiatietoihin lisätään käskyrivi niin ennen lisäämistä poistetaan edelliset täysin samanlaiset rivit antamalla käskyn: export HISTCONTROL=erasedups . Kun lisäät sen käskyksi tiedostoon ~/.bashrc niin se on päällä aina.

- voit editoida historiatiedostoa: gedit .bash_history

- joskus kirjoittaessasi pitkää käskyä tajuatkin että ensin täytyy antaa muita käskyjä. Kirjoita vaan käsky loppuun ja kirjoita käskyn ensimmäiseksi merkiksi # ja paina enter. Käsky menee historiaan kommenttina. Anna muut käskyt, hae historiasta tuo kommentoitu käsky ja poista sen alusta merkki # ja paina enter - nyt käsky tosiaan suoritetaan.

- kun olet aikaansaanut historiatiedoston jossa on kaikki mitä voit kaivata poista historiatiedoston kirjoitusoikeus käskyllä: CHMOD -x . ~/.bashrc ettei se sotkeennu.

- istunnon alkaessa tiedosto ~/.bash-history latautuu mistiin ja tätä muistissa olevaa käsitellään. Käskyllä: history -c nollautuu näytössä oleva historia, mutta levyyn se ei koske. Muistissa oleva historia kirjoitetaan levylle vasta kun  istunto loppuu.

- Kun Linuxin on tehty niin tarkoituksena on ollut että ***suuressa*** käyttäjä-joukossa kaikki saavat tukea toisilta - myös hyper-virtuoosit tarvitsevat apua ja ilman toisia kukaan ei ole mitään. Näin myös historian kanssa. Historiatietoihin voi käskyllä:   
« Viimeksi muokattu: 09.01.13 - klo:13.23 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #13 : 19.04.12 - klo:12.03 »
Muutinpa skripti-ajurin tulostamaan virheensä tiedostoon. Kaikkiallahan kaiutetaan kuinka helppoa se periaatteessa on: käsky 2> tiedosto. Vaan ei toiminut skriptissä vaikka päätteessä toimikin. Luin miljoona verkkosivua löytääkseeni se maagisen ohjeen jolla uudelleenohjauksen saa toimimaan skriptissä. Lopulta törmäsin verkkosivulle jossa oli seuraavat tekstit, kylläkin ilman selityksiä:
program-name 2> error.log
command 2> error.log
- siis yksinkertaisesti: skriptille täytyy myös kertoa uudelleenohjauksesta.
- varmaankin homman löytää nyt monesta paikasta kun tietää täsmälleen mitä etsii. Sen käsittää ettei dokumentointia liiemmälti harrasteta, mutta olisi kiva jos oppaissa edes vihjattaisiin siitä aivan perusteiden yhteydessä.

ajaaskel

  • Palvelimen ylläpitäjä
  • Käyttäjä
  • Viestejä: 3383
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #14 : 19.04.12 - klo:14.18 »
Kertoisitko jonkun esimerkin missä  2>virhe.txt ei toimi niin katsotaan ?   Kannattaa yleensä käyttää muotoa  2>>virhe.txt (eli kaksi väkästä= kirjoita olemassaolevan perään) jolloin toinen virhe ei ylikirjoita ensimmäistä vaan se virhe kirjoitetaan muiden tekstien perään siellä tiedostossa.  Jossain tilanteessa on kätevää ohjata merkityksettömät virheet yksinkertaisesti harakoille 2>/dev/null pois silmistä.   Jos tarvitset "sekä ykköseen että kakkoseen" menevät viestit tiedostoon niin
Koodia: [Valitse]
&>>kaikki.txt voisi olla sopiva.   Jos tarvitset sekä näytölle että tiedostoon niin "tee" komento on apulaisesi.

Edit:
Huomaa, että tuon kakkosen ja väkäsen välissä ei saa olla tyhjää, parempi kirjoittaa kokonaan yhteen kakkosesta eteenpäin.
« Viimeksi muokattu: 19.04.12 - klo:14.27 kirjoittanut ajaaskel »
Autamme ilolla ja ilmaiseksi omalla ajallamme.  Ethän vaadi, uhoa tai isottele näin saamasi palvelun johdosta.

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #15 : 19.04.12 - klo:16.02 »
Lisäsin Skriptiajuriin funktion, joka muuttaa määrättävän sanan kaikissa Skriptiajurin tiedostoissa. Mutta nyt pähkäilen kannattaako sitä käyttää: kun muuttaa jonkun tärkeän sanan Skriptiajurissa ei ole minkäänlaisia mahdollisuuksia muuttaa sitä käsin kaikkialla, kyllä siihen tarvitaan ohjelmaa. Ongelma on se että muutoksia on niin monta, että jos aina kysyttäisiin:"saako tässä vaihtaa" niin joutuisi painelemaan enteriä viikon ajan, mutta jos ei kysytä niin tuleehan siinä pakostakin välillä harha-iskuja.
« Viimeksi muokattu: 20.03.13 - klo:12.59 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #16 : 04.05.12 - klo:20.34 »
Jo parivuotta olen käyttänyt kummallisia tiedostonimiä paljonkin eikä *mitään* vaikeuksia ole esiintynyt. Muutamassa erittäin haetussa erikois-tapauksessa toiminta on tosin puutteellista; esimerkiksi tiedoston nimeltää: * ollessa kansiossa nimeltää: *  .
- onkohan perää myöskään väitteissä että kummallisuuksia sisältävien skriptien toimiminen toisissa koneissa saattaa olla huono?  
- skriptiajuri ei välitä siitä, minkä kielisiä skriptejä sillä ajetaan. Ja sitä voi käyttää vaikka runoja tehtäessä.
- samoin funktiokutsuissa voi huoletta käyttää ääkkösiä. Välilyönnit täytyy kylläkin muuttaa alle-viivauksiksi. Skriptin listaus kylläkin muuttuu inhottavaksi vierailla kielillä.
___________________________________________________________________________________________

Hakutuloksiin ei pidä sotkea hakutuloksia ARKISTOista, sillä ARKISTOista-hakujen osumien määrä on todella suuri ja niissä on yleensä mahdottomasti toistoa. Mutta ARKISTOsta joutuu joskus etsimään kuten esimerkiksi:
Skripti voidaan tehdä lukemattomilla erilaisilla tavoilla. Eri toimintatapojen suorituskyvyt ja koot vaihtelevat "tuhatkertaisesti". Kun tekee skriptiä johonkin tehtävään kannattaakin kokeilla erilaisia toteutustapoja; ja periaate on että saman tehtävästä kaikki laitetaan samaan paikkaan eikä jokaisesta kokeilu-tavasta tehdä omaa projektiaan. Mutta kaikki kokeet sijoitetaan projektin omaan ARKISTOon. Kun myöhemmin huomaat että se aikaisempi tapa oli parempi saat haettua millainen se oli.  
Jos muistaa jotakin kyseiselle toteutustavalle ominaista antaa haku kyseisen projektin ARKISTOsta niiden arkistokappaleiden numerot joista kyseinen ilmaisu löytyy.
Arkistokappaleista voi lisäksi kokeilla kuinka ne toimivat ja editoriin saa kyseisen arkistokappaleen ja sen millaiseksi se on nyt editoitu. Joten kopiointi niiden välillä on helppoa.
__________________________________________________________________________________________

Tietokoneen vihulaisohjelmat muuttuvat jatkuvasti pahemmiksi eikä teoriassa mihinkään voi enää luottaa. Ei tilanne käytännössä ole vielä paha varsinkaan Linuxin suhteen, mutta pahempaa kohti mennään ja kun loppurysähdys tulee on se nopea ja paha.
Yhtä perustelua Linuxin turvallisuuden puolesta esitetään jatkuvasti: Linuxissa kaiken koodin saa tarkistettavakseen myös selväkielisenä tekstinä - käytännössä noista ajoista on jo kauan.
No, oletetaan että itse käyttöjärjestelmän koodi on puhdas. Entäpä ohjelmat ? Ne on käännetty eikä lähdekoodia saa.
Mutta skripteissähän on lähdekoodi ilmanmuuta mukana? Mutta useimmat skriptit käyttävät käännettyjä ulkoisia paketteja jotka vielä usein ovat peräisin Reino Rehdin PPA:sta. Lopputulos on se että voit käyttää vain itsetekemiäsi skriptejä.

Mutta skriptinteko on niin hankalaa kun niiden tekemiseen ei ole kunnollista käyttöympäristöä (=IDE:ä)? Skriptiajuri on moitteeton IDE ja se käyttää vain niitä paketteja jotka kuuluvat Ubuntun perusasennukseen.
_______________________________________________________________________________________
Tässä aikoinaan puhuttiin paljon 'just in time'-kääntämisestä ja onhan siinä järkeäkin: mitä sitä hommia tehdä ennenkuin tuloksia tarvitaan. BASH toimii muuten juuri tuolla periaatteella: mikäli tekee hommat oikein se hidastelee siellä missä se ei tunnu. BASH on todellisten virtuoosien tekemä: olisikohan jotenkin mahdollista että se toimii hitaasti koska ihminen tarvitsee "hitautta"?
Silti skriptien hitaus joskus harmittaa. Mutta toisaalta se merkitsee vain, että skriptiä ei voi tehdä kuinkavaan ->  " Jokainen skripti voidaan toteuttaa tuhansilla tavoilla. Skriptien suoritusajat vaihtelevat tuhatkertaisesti. Olet pätevä skriptintekijä jos pääset lähellekään kärkijoukkoa. Mutta mikäli jatkuvasti löydät niitä parhaita ratkaisuja olisi aika muuttaa lääkitystäsi. "
__________________________________________________________________________________________
Minulle on aina ollut ihmetyksen aihe se minkätakia skriptit halutaan nimettäviksi siten, että niissä on peräliitteenä .sh (tai ...)
Olen skriptannut nyt pari vuotta ammattimaisesti, enkä ole nimennyt ensimmäistäkään skriptiäni peräliitteellä .sh
Yhden idioottimaisen syyn keksin: siten yritetään kertoa: "tämä on skripti"
______________________________________________________________________________________________
Alkoi selvitä, miksi BASH on huonossa hapessa: asia on ihan sama kuin se ettei Linux saa vallattua markkinoita Windowsilta: pahin este siinä on se että firmojen IT:t osaavat toimia Windowsin kanssa hyvin mutta Linuxin kanssa hyvin huonosti ja vastustavat muuttamista Linuxiin kirjaimellisesti "verisesti".

Mikä on BASH:in Windows? Se on Python; avainhenkilöt osaavat sitä ja heille paluu BASH:iin olisi liian noloa. Aikoinaan kun aloin toimia BASH:in kanssa olin itsekin siinä käsityksessä ettei BASH:ista ole Pythonin rinnalla mihinkään. Mutta eteen on tullut omituisia tilanteita.

Jos oppaita kirjoittava harrastaa skriptausta ollenkaan niin  sitten PYTHON:ia tai PERL:iä. Eihän hän "vihollisen" hyviä puolia opeta - sillä BASH taitaa hakata PYTHON:it jos tilaisuus annettaisiin; siis se BASH jonka olemassaoloakaan ei tunnusteta.
« Viimeksi muokattu: 21.09.13 - klo:14.15 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #17 : 01.01.13 - klo:15.43 »
BASH:illa voi paitsi toteuttaa mitähyvänsä myös toteuttaa se ziljoonalla tavalla. Esimerkki siitä kuinka päiväys voidaan näksytellä hiirellä:

Koodia: [Valitse]
#!/bin/bash
kanta=${0%/OMATSKRIPTIT*}; echo 'tätä skriptiä ajetaan paikasta: '$kanta  
. "$kanta"/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkohiirelle # Kirjastosta liitetään koodi tiedostosta Valikkonäppäimille tämän skriptin koodiin.

IFS=". " read -r viikonpaiva paiva kuukausi vuosi tunti minuutti sekunti alue <<< $(date); unset IFS

while true; do
  Kuukaudessa31paivaa='1||3||5||7|8||10||12'; IFS="|"; set -- $Kuukaudessa31paivaa; unset IFS; [[ $(eval echo \${$kuukausi}) ]] && Valittavat=("vaihda vuosi" "vaihda kuukausi" {1..31})  
  Kuukaudessa30paivaa='|||4||6|||9||11||'; IFS="|"; set -- $Kuukaudessa30paivaa; unset IFS; [[ $(eval echo \${$kuukausi}) ]] && Valittavat=("vaihda vuosi" "vaihda kuukausi" {1..30})  
  Kuukaudessa28paivaa='|2|||||||||||'; IFS="|"; set -- $Kuukaudessa28paivaa; unset IFS; [[ $(eval echo \${$kuukausi}) ]] && Valittavat=("vaihda vuosi" "vaihda kuukausi" {1..28})  
  ValitseValittavistaYksi "Tämänhetkinen päiväys: "$paiva" "$kuukausi" "$vuosi" valitse uusi päivä:" " " $(($paiva+2))  
  [[ $ValitunTeksti = "vaihda kuukausi" ]] && Valittavat=({1..12}) && ValitseValittavistaYksi " valitse kuukausi: " "" $kuukausi && kuukausi=$ValitunTeksti && continue
  [[ $ValitunTeksti = "vaihda vuosi" ]] && Valittavat=({1900..2050}) && ValitseValittavistaYksi " valitse vuosi: " "" $(($vuosi-1899)) && vuosi=$ValitunTeksti && continue
  reset; paiva=$ValitunTeksti; echo 'Valitsit päivän: '$paiva" "$kuukausi" "$vuosi && exit
done


koodi valikkonäppäimille löytyy sivulta: http://forum.ubuntu-fi.org/index.php?topic=303.msg296419#msg296419

Miksi tehdä tämmöistä kun käyttöjärjestelmän oma on parempi ? Ja jos koodata haluaa niin miksei keskittyisi käyttöjärjestelmän käskyyn : cal ?

Eiköhän sekin vielä selviä.
« Viimeksi muokattu: 10.02.13 - klo:12.41 kirjoittanut petteriIII »

petteriIII

  • Käyttäjä
  • Viestejä: 578
    • Profiili
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #18 : 10.02.13 - klo:12.30 »
- saadaksesi Skriptiajurin toimimaan anna ensi käsky: mkdir -p ~/OMATSKRIPTIT/FUNKTIOKIRJASTO && mkdir -p ~/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, näppäinversio" && mkdir -p ~/OMATSKRIPTIT/OHJEITA/"Skriptiajuri, hiiriversio" && mkdir ~/OMATSKRIPTIT/"KOE- JA ESIMERKKISKRIPTIT" && touch ~/OMATSKRIPTIT/"Skriptiajuri, näppäinversio" ~/OMATSKRIPTIT/"Skriptiajuri, hiiriversio" ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot1 ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot2 ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkonäppäimille ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkohiirelle ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/Xref_funktiot ~/OMATSKRIPTIT/"KOE- JA ESIMERKKISKRIPTIT"/kertotaulu ~/OMATSKRIPTIT/OHJEITA/{"Skriptiajuri, näppäinversio","Skriptiajuri, hiiriversio"}/{arkistonkäyttö,"geditin ja päätteen asetukset",nappulatekniikkaa,"uudet käskyt"} 

hae kopiopöydälle koodit sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg293780#msg293780
ja liitä toinen tiedostoon: ~/OMATSKRIPTIT/Skriptiajuri, näppäinversio
ja liitä toinen tiedostoon: ~/OMATSKRIPTIT/Skriptiajuri, hiiriversio

hae kopiopöydälle koodi sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg300081#msg300081
ja liitä se tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot1

hae kopiopöydälle koodi sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg300185#msg300185
ja liitä se tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/IDEfunktiot2

hae kopiopöydälle koodi sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg296419#msg296419  
ja liitä se tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkonäppäimille

hae kopiopöydälle koodi sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg295198#msg295198
ja liitä se tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/valikkohiirelle

hae kopiopöydälle koodi sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg303513#msg303513
ja liitä se tiedostoon: ~/OMATSKRIPTIT/FUNKTIOKIRJASTO/Xref_funktiot

Ja kannattaa hakea yksi esimerkkiskripti ja muutama ohje, esimerkiksi: http://forum.ubuntu-fi.org/index.php?topic=303.msg292029#msg292029
ja liitä se tiedostoon ~/OMATSKRIPTIT/KOE- JA ESIMERKKISKRIPTIT/kertotaulu

Mikäli haluat IDE:en käyttöohjeita niin hae koodit sivuilta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg302036#msg302036
ja liitä ne ehdotettuihin paikkoihin

Uusien käskyjen ohjeet löutyvät sivulta: http://forum.ubuntu-fi.org/index.php?topic=44605.msg305254#msg305254
liitä ne ehdotettuihin paikkoihin


- anna käsky: chmod +x ~/OMATSKRIPTIT/"Skriptiajuri, näppäinversio" && chmod +x ~/OMATSKRIPTIT/"Skriptiajuri, hiiriversio"
- jos unohdat antaa IDE:lle suoritusoikeuden, saat ajo-yrityksestä virheviestin: permission denied
- Millä Linuxilla näitä IDE:jä käytätkin niin  Linuxeihin täytyy ladata tekstinkäsittely-ohjelma gedit. Yleensä se käy käskyllä: sudo apt-get instal gedit .
- yleensä IDE:jä voi ajaa mýös laitteen tiedostoselaimella (nautilus, Dolphin, Pluma ... ).
- yleensä näiden skriptien ajamilla skripteillä ei täydy olla suoritusoikeutta, ei riviä #!/bin/bash, nimien pituus ja merkkivalikoima ovat rajoittamattomia, nimien peräliite .sh kannattaa jättää pois ...
- skriptejä voi ajaa tikultakin. Käyttöoikeudet, polut ja tiedostomuoto vain oikeiksi.
- ajettaessa ensimmäistä kertaa IDE:t alustavat nyt OMATSKRIPTIT-kansion, joten enää ei tarvita kikkailua. Kumpikin IDE toimii samassa ympäristössä ja toinen alustaa myös toisen; ja siirryttäessä IDE:stä toiseen toinen jatkaa siitä mihin toinen lopetti. Muuten IDE:llä voi ajaa myös toista IDE:ä.

- käskyllä ~/omatskriptit/"Skriptiajuri, hiiriversio" voi ajaa skriptiä: Skriptiajuri, hiiriversio
ja käskyllä ~/omatskriptit/"Skriptiajuri, näppäinversio" voi ajaa skriptiä: Skriptiajuri, näppäinversio
- Skriptiajurit:t muuttuvat nyt niin nopeasti että kestää jonkiaikaa tarkistaa onko foorumille kirjoitetusta kaikki toimivaa
                                                          -------
Nyt alkaa tulla pientä tarvetta skriptien debuggaamiseen. Debuggaamiseenkin on monta keinoa ja yksi niistä kevyimmistä keinoista on laittaa epäilyttävän koodin-pätkän eteen:
set -x; trap "echo hit return;read x" DEBUG           ja koodin-pätkän perään:
set +x; trap "" DEBUG


IDE:llä on nopeaa kokeilla mitä perää on uskomuksissa. Esimerkiksi matriisin passaaminen parametrina, ainakin minulle sen on kerrottu olevan mahdotonta:

Koodia: [Valitse]
#!/bin/bash
function Tulosta_matriisi () {
eval echo -e "' '\${$1[@]/%/\\\n}"  
}

matriisi[1]="Marilla oli karitsa"
matriisi[2]="sen villa lumivalkoinen"
matriisi[3]="minne Mari menikään"
matriisi[4]="karitsa meni perässään"
Tulosta_matriisi matriisi
 
for n in {22..32}; do y[$n]=$n; done
Tulosta_matriisi y

- ziljoona jäseninen matriisi tulostuu myös. Kaksi-dimensioisen matriisin tulostukseen joutuu koodia puukottamaan vähän:
Koodia: [Valitse]
#!/bin/bash
function Tulosta_matriisi_rivi () {
eval echo -e \${$1[@]}
}

function Tulosta_matriisi_kokonaan () {
Sarakeluku=$2
Rivi=0
while true; do
  for (( n=1; n<=Sarakeluku; n++ )); do  
    [[ ! $(eval echo -e \${$1[n+$Sarakeluku*Rivi]}) ]] && return
    xxxx=$xxxx" "$(eval echo -e \${$1[n+$Sarakeluku*Rivi]})
  done
  Tulosta_matriisi_rivi xxxx
   xxxx=''
  let Rivi++
done
}  


matriisi[1]="Marilla oli karitsa"
matriisi[2]="sen villa lumivalkoinen"
matriisi[3]="minne Mari menikään"
matriisi[4]="karitsa meni perässään"
Tulosta_matriisi_kokonaan matriisi 1 # koska BASH:issa ei ole kaksiulotteisia matriiseja niin tässä on  tehty samoin kuin normaalistikin: kaksiulotteinen kuvataan yksiulotteisessa
# taittaen se rivi kerrallaan. Kutsun kirjoitusasu on: Tulosta_matriisikokonaan <tulostettavan matriisin nimi> <sarakkeiden luku tulosteessa>
# samalla menetelmällä voi kuvata kolmi-dimensioisetkin
echo
 
for n in {100..243}; do mahtavamatriisi[$n-99]=$n; done
Tulosta_matriisi_kokonaan mahtavamatriisi 12
read -p 'jatkaakseesi paina enter'

- tämä on käsittääkseeni ratkaisu BASH:in pahimpaan pulmaan: luullaan että yleiskäyttöinen funktio on mahdottomuus. Parametrin palautusta ei hyödynnetä, mutta sekin on näissä ja paljon parempana kuin yleensä onkaan: parametreja ei täydy edes määritellä.
- siis sama funktio tulostaa olipa matriisin muoto mikähyvänsä yksi- tai kaksiulotteinen.
« Viimeksi muokattu: 02.04.13 - klo:11.42 kirjoittanut petteriIII »

Tomin

  • Palvelimen ylläpitäjä
  • Käyttäjä / moderaattori+
  • Viestejä: 10513
    • Profiili
    • Tomin kotisivut
Vs: Ohjeita shell-skriptaukseen (bash)
« Vastaus #19 : 22.02.13 - klo:23.29 »
Voisit varmaan hostata noita tiedostoja kätevämminkin jossain palvelussa kuten:
Github: https://github.com/
Gitorious: http://gitorious.org/
Bitbucket: https://bitbucket.org/
Launchpad: https://launchpad.net/
Google Code: http://code.google.com/intl/fi/
Sourceforge: http://sourceforge.net/
tai joku muu sellainen: http://en.wikipedia.org/wiki/Comparison_of_open_source_software_hosting_facilities
Listasin tuossa ne mitä tuli mieleen. Ainakin osa vaatii jonkin versionhallinnan käyttöä, mutta se ei välttämättä ole huono asia.

Toinen juttu, joka helpottaisi tiedostojen jakelua on tarrapallo eli ne voisi pakata yhteen tiedostoon.

Kolmantena taidan siirtää nämä skriptiajurijutut omaan säikeeseen, helpottaa sopivien viestien löytämistä. :)

Muokkaus: Jaoin kyllä, mutta paljon viestejä jäi alkuperäiseen aiheeseen, koska foorumisofta ei ole kovin fiksu. Pikamoderoinnilla noita naksuttelisi äkkiä, mutta tämä ei anna kuin poistaa sitä kautta. Siispä puuttuvia viestejä pitää etsiä tuolta: http://forum.ubuntu-fi.org/index.php?topic=303.0

Vaivoin siirtelin noita yksittäin. Toivottavasti mitään olennaista ei jäänyt väliin ja jos jäi, niin saa mainita. Nyt menen nukkumaan.
« Viimeksi muokattu: 23.02.13 - klo:00.13 kirjoittanut Tomin »
Automaattinen allekirjoitus:
Lisäisitkö [RATKAISTU] ketjun ensimmäisen viestin aiheeseen ongelman ratkettua, kiitos.