Etikettendruck mit Script

TeXpert · 12 Okt. 2005

so, jetzt hatte ich auch mal ein wenig Zeit

und hab mal mit der Idee rumgespielt... ich bin einen anderen Weg als robi gegangen, ich wollte ohne zusätzliche Dateien auskommen, d.h. ich arbeite nur mit einem einmal eingelesenen Array... hier ist noch Optimierungspotential, denn die Ausgabe kann auch on the fly passieren... dadurch kommt man nicht in Speicherprobleme..

BTW: Lord_Levithanius, bestell Deinem Programmierer einen schönen Gruß

das werde ich mir mal in die Liste der möglichen Testaufgaben stecken denn um das halbwegs elegant mit Bash zu lösen muss man echt etwas überlegen...

gefordert war ja, die Adressen fortlaufend in zeilen mit Wiederholungen rauszuschreiben:

A1 A1 A2 A2
A3 A3 A4 A4

meine Ergebnisse:

Code:

$ ./aprint.sh adressen.txt 3 2
----------------------------------------------------------------------------
| Jack Daniels           | Jack Daniels           | Susanne Sorglos        |
| Verköstung             | Verköstung             | Verwaltung             |
| Blaue Allee 15         | Blaue Allee 15         | Jodel Str. 21          |
| 29640 Schneverdingen   | 29640 Schneverdingen   | 29640 Schneverdingen   |
----------------------------------------------------------------------------
| Susanne Sorglos        | Markus Mustermann      | Markus Mustermann      |
| Verwaltung             | Muelltrennung          | Muelltrennung          |
| Jodel Str. 21          | Musterstrasse 77       | Musterstrasse 77       |
| 29640 Schneverdingen   | 29614 Soltau           | 29614 Soltau           |
----------------------------------------------------------------------------
| Otto Mueller           | Otto Mueller           | Hans Wurst             |
| Abteilung bla          | Abteilung bla          | Abteilung 3            |
| abcstrasse 1           | abcstrasse 1           | blabla weg 7           |
| 12345 stadt            | 12345 stadt            | 56789 quasselstadt     |
----------------------------------------------------------------------------
| Hans Wurst             |                        |                        |
| Abteilung 3            |                        |                        |
| blabla weg 7           |                        |                        |
| 56789 quasselstadt     |                        |                        |
----------------------------------------------------------------------------

das ganze geht auch mit mehr als 4

Code:

$ ./aprint.sh adressen.txt 5 1
------------------------------------------------------------------------------------------------------------------------------
| Jack Daniels           | Susanne Sorglos        | Markus Mustermann      | Otto Mueller           | Hans Wurst             |
| Verköstung             | Verwaltung             | Muelltrennung          | Abteilung bla          | Abteilung 3            |
| Blaue Allee 15         | Jodel Str. 21          | Musterstrasse 77       | abcstrasse 1           | blabla weg 7           |
| 29640 Schneverdingen   | 29640 Schneverdingen   | 29614 Soltau           | 12345 stadt            | 56789 quasselstadt     |
------------------------------------------------------------------------------------------------------------------------------

oder

Code:

$ ./aprint.sh adressen.txt 1 1
--------------------------
| Jack Daniels           |
| Verköstung             |
| Blaue Allee 15         |
| 29640 Schneverdingen   |
--------------------------
| Susanne Sorglos        |
| Verwaltung             |
| Jodel Str. 21          |
| 29640 Schneverdingen   |
--------------------------
| Markus Mustermann      |
| Muelltrennung          |
| Musterstrasse 77       |
| 29614 Soltau           |
--------------------------
| Otto Mueller           |
| Abteilung bla          |
| abcstrasse 1           |
| 12345 stadt            |
--------------------------
| Hans Wurst             |
| Abteilung 3            |
| blabla weg 7           |
| 56789 quasselstadt     |
--------------------------

nicht erschrecken

aber mit Kommentaren und Sicherheitsnetz (eingabeüberprüfung) komme ich auf

Code:

$ wc -l aprint.sh
192 aprint.sh

Zeilen....

Anonymous · 12 Okt. 2005

@TeXpert
hast mich wie immer geschlagen, allerdings was macht denn dein Script wenn die 80 Zeichen in der Zeile nicht mehr ausreichen? :shock: :wink:

*nur-Späßle-g'macht*
na dafür ist mein script aber so richtig niedlich

Code:

LINUX:/tmp/test # ls -l
insgesamt 10
drwxr-xr-x   2 rob  users   96 2005-10-12 20:48 .
drwxrwxrwt  48 root root  1784 2005-10-12 20:45 ..
-rw-r--r--   1 rob  users  297 2005-10-12 20:44 adressen
-rwxr--r--   1 rob  users  409 2005-10-12 20:48 script
LINUX:/tmp/test # wc script
 36  88 409 script

und wenn ich mich noch ein bissel mehr anstrenge, dann ließt es sich wie deine Signatur :lol:

robi

Lord_Levithanius · 13 Okt. 2005

Freut mich, dass ihr anscheinend so viel Spaß damit habt!

Ich werde mal versuchen dem Herrn nächste Woche die Lösung zu entlocken...
Sehe ihn erst am Montag wieder, da er jetzt gerade irgendwo in Berlin rumschwirrt

Gruss,
Levi

TeXpert · 13 Okt. 2005

Lord_Levithanius schrieb:
Freut mich, dass ihr anscheinend so viel Spaß damit habt!

solche Dinge sind eine nette Abwechselung gegenüber den hier häufig aufschlagenden "Hey XYZ funzt nicht, sach mal was ich tippen muss..." und das sind immer wieder nette Fingerübungen, wenn man mal ein paar Minuten Zeit hat...

Ich werde mal versuchen dem Herrn nächste Woche die Lösung zu entlocken...

das ist Feigheit vor dem Feind... wo ist Deine Lösung? wo hapert es?....

robi schrieb:
@TeXpert
hast mich wie immer geschlagen, allerdings was macht denn dein Script wenn die 80 Zeichen in der Zeile nicht mehr ausreichen? Shocked Wink *nur-Späßle-g'macht*

das ist nur ein kosmetisches Problem

Du musst natürlich sicherstellen, dass die einzelnen Felder auf die tty-Breite passen (warum auf 80-Zeichen begrenzen?)

Aber recht Du hast, hier wäre sicherlich noch eine Abfrage nett, die die maximale Breite berücksichtigt

na dafür ist mein script aber so richtig niedlich
[...]
und wenn ich mich noch ein bissel mehr anstrenge, dann ließt es sich wie deine Signatur

zeigen

nachdem der Lord wohl vor lauter Feigheit hier kapituliert und lieber Hilfe von Cheffe haben will, können wir ja auch unsere Versionen hier posten oder nicht?[/quote]

Anonymous · 13 Okt. 2005

Ich glaube meine kann ich schon getrost reinstellen,
die wird sich niemand getrauen seinem Chef vor die Füße zu werfen :wink:

Wer hieraus ein Cheftaugliches Script machen kann, hat das Potential in der selben Zeit auch selbst ein eigenes zu schreiben. Mit deiner kannst du ja sicherheitshalber noch ein paar Tage warten

Code:

#! /bin/bash
export S=Sammel_
druck()
{
 for i in `seq 1 $2`
   do
    if [ $3 ]
      then
      cat $3 >> $S$1 ; echo "------------------" >> $S$1
      fi
   done
}

folge()
{
 if [ $1 -ge $2 ]
   then
     read A
     druck $2 $3 $A
 fi
}

split -5 -a4 $3 A_
echo -e "\n\n"

ls A* | while read A
do
 druck 1 $1 $A
 for i in 2 3 4
  do
   folge $2 $i $1
  done
done

pr -m -t -w80 -s'|' $S?
rm A_????  $S?

Achtung: Dateien mit die mit "A_" und "Sammel_" am Anfang beginnen sollten sich nicht im aktuellem Verzeichniss befinden, die werden knadenlos gelöscht. Und der schönheitshalber hinter die letzte Adresse im Adressfile eine Leerzeile setzten.
Aufruf ./script ANZAHL SPALTEN ADRESSDATEI

robi

regexer · 13 Okt. 2005

Werde auch mal meine 120-Zeilige Lösung zum Besten geben. Es arbeitet mit meinem Vorgeschlagenen CSV-Format. Im Übrigen hat es sicher noch Optimierungspotential (ich verwende 4 Arrays und 4 for-schleifen). Zweidimensional sieht das denke ich um einiges besser aus. Dafür ist es schon ziemlich flexibel, was das Ermitteln der Etikettengröße angeht...

Code:

#!/bin/bash

# Optionen
formularbreite=80   # in Zeichen
rand_links=2        # linker Rand pro Etikett in Zeichen
rand_rechts=2       # rechter Rand pro Etikett in Zeichen
rand_oben=1         # oberer Rand pro Etikett in Zeilen
rand_unten=1        # unterer Rand pro Etikett in Zeilen
datei=adressen.txt  # Eingabedatei mit Adressen
delimiter=";"       # Feldtrenner in Eingabedatei

typeset -i kopien
typeset -i bahnen
kopien="$1"
bahnen="$2"

if [[ "$1" -eq 0 ]]   # als Parameter 1 wurde keine Zahl eingegeben
then
  kopien=1    # default
fi

if [[ "$2" -eq 0 ]]
then
  bahnen=1    # default
fi

# Bahnbreite ausrechnen. expr rundet automatisch ab
bahnbreite=`expr $formularbreite / $bahnen - $rand_links - $rand_rechts`

if [[ "$bahnbreite" -lt 1 ]]
then
  echo "$bahnen Etiketten passen nicht nebeneinander auf die Seite"
  exit 2
fi

function leerzeilen () {
  if [[ "$1" -gt 0 ]]     # wurde leerzeilen mit parameter aufgerufen?
  then
    for i in `seq $1`
    do
      printf "\n"
    done
  fi
}

function ausgabe () {

  for j in `seq $kopien`
  do

    leerzeilen $rand_oben

    for i in `seq $bahnen`
    do
      printf "%${rand_links}s"           # Rand links ausgeben
                                         # Adresszeile linksbuendig ausg.
      printf "%-${bahnbreite}s" ${a1[$i]}
      printf "%${rand_rechts}s"          # Rand rechts ausgeben
    done
    printf "\n"                          # Zeilenvorschub

    for i in `seq $bahnen`
    do
      printf "%${rand_links}s"
      printf "%-${bahnbreite}s" ${a2[$i]}
      printf "%${rand_links}s"
    done
    printf "\n"
    for i in `seq $bahnen`
    do
      printf "%${rand_links}s"
      printf "%-${bahnbreite}s" ${a3[$i]}
      printf "%${rand_rechts}s"
    done
    printf "\n"
    for i in `seq $bahnen`
    do
      printf "%${rand_links}s"
      printf "%-${bahnbreite}s" ${a4[$i]}
      printf "%${rand_rechts}s"
    done
    printf "\n"

    leerzeilen $rand_unten

  done

  unset a1[*]
  unset a2[*]
  unset a3[*]
  unset a4[*]
}

IFS="$delimiter
"

spalte=1
anz_adressen=`wc -l $datei | awk '{print $1}'`

cat $datei |
while read zeile1 zeile2 zeile3 zeile4 rest   # lese Zeilenweise
do
  let adress_nr++

                                       # Array fuellen
  a1[$spalte]=${zeile1:0:$bahnbreite}  # dabei zu lange Zeilen abschneiden
  a2[$spalte]=${zeile2:0:$bahnbreite}
  a3[$spalte]=${zeile3:0:$bahnbreite}
  a4[$spalte]=${zeile4:0:$bahnbreite}

  let spalte++                   # Spalte um 1 erhoehen

  # Spaltennummer groesser als Bahnenanzahl
  # oder letzte Adresse
  if [ "$spalte" -gt "$bahnen" -o "$adress_nr" -eq "$anz_adressen" ]
  then
    ausgabe                      # Funktionsaufruf zur Ausgabe
    spalte=1
  fi

done

Als adressen.txt verwendete ich:

Code:

Sepp Dimpfelmoser;;Am Wald 1b;99999 Hintertupfing
R. Hotzenplotz;Gold-Annahme;Raeuberhoehle 12;88888 Wald
name1;abteilung1;strasse1;ort1
name2;abteilung2;strasse2;ort2
name3;abteilung3;strasse3;ort3
name4;abteilung4;strasse4;ort4
name5;abteilung5;strasse5;ort5

TeXpert · 13 Okt. 2005

@robi, ach was... er müsste mein Programm ja auch verstehen

erst mal zu Deinem Programm

schön kryptisch, da brauch ich ein wenig um das nachzuvollziehen ... aber warum exportierst Du "S"? das verwirrt mich direkt am Anfang...

Code:

#!/bin/bash

###########################################################
###
### Scriptspielerei
###
### -------------------------------------------------------
###
### (c) 2005, TeXpert
### für linux-club.de
### Referenz: http://www.linux-club.de/viewtopic.php?t=43489
### Version 0.2
###
### -------------------------------------------------------
###
### aufruf: scriptname Adressdatei Spaltenzahl wiederholungen
###
### Bemerkung: hardcoded für Anforderung von 4-zeiligen Adressen!
### Parametrisierung: FIELDWIDTH=23 beschreibt die Breite
### der Etiketten -> nach Belieben anpassen. (Anmerkung: 
### formatierte Textausgabe mit der Bash ist eine Quälerei ;) 
###
###########################################################


# pseudo-Constant - Label-breite
FIELDWIDTH=23


# Variablen
ADRESSEN_DATEI=
SPALTEN
WIEDERHOLUNG
NUMMER=0
ADRESS_ZEILE=0
ADRESSE=0
AUSGABE=0
declare -a ARRAY
declare -a ZEILEN_PUFFER
FIELD=$(printf "%${FIELDWIDTH}s" " ")


############################

function usage {
  echo "$1"
  echo "Aufruf: $0 adressendatei(DATEI) spaltenanzahl(INTEGER>0)
  wiederholungen(INTEGER>0)"
  exit 1
}

function drucke_linie {
  for i in $(seq $(( ($FIELDWIDTH +2) * $SPALTEN + 1)) )
  do 
    echo -n "-"
  done
  echo
}
function drucke_zeile {
  local line
  drucke_linie
  for z in $(seq 0 3)
  do
    line=""
    for s in $(seq 0 $(( $SPALTEN -1 )) )
    do
      curfield="${ZEILEN_PUFFER[$(($s * 4 + $z))]}$FIELD"
      curfield=${curfield:0:$FIELDWIDTH}
      if [ -n "$line" ]
      then
        line="$line$curfield| "
      else 
        line="| $curfield| "
      fi
    done
    echo "$line"
  done
}


############################


## Eingabevalidierung
# Anzahl
if [ "$#" -eq 3 ] 
then
  ADRESSEN_DATEI="$1"
  SPALTEN="$2"
  WIEDERHOLUNG="$3"
else
  usage "falsche Parameter!"
fi
# Datei
if [ ! -f "$ADRESSEN_DATEI" ]
then
  usage "Adressdatei existiert nicht!"
fi
# Zahlenbereiche
shopt -s extglob
if [[ $SPALTEN != +([1-9])*([0-9]) ]]
then
  usage "Spalten ist kein positiver Integer"
fi
if [[ $WIEDERHOLUNG != +([1-9])*([0-9]) ]]
then
  usage "Wiederholung ist kein positiver Integer"
fi
shopt -u extglob



## Jetzt Adressen parsen
## Datensätze werden durch genau 1 Leerzeile getrennt!
## wenn Leerzeilen in der Liste sind, werden leere Datensätze 
## gespeichert... -> sollte man abfangen
##
## speichern in einem Array:
## a[i]=name
## a[i+1]=abteilung
## a[i+2]=strasse
## a[i+3]=ort/plz
##
## ein Adressdatensatz:
## a[nummer*4 + j] wobei $j \in \{0,\ldots,3\}$

while read line
do
  if [ -z "$line" ]
  then 
    let "NUMMER += 1"    
    let "ADRESS_ZEILE = 0"
  else
    ARRAY[$(( ($NUMMER * 4) + $ADRESS_ZEILE))]="$line"
    let "ADRESS_ZEILE += 1"
  fi
done < $ADRESSEN_DATEI



## Ausgabe, schreibe Ausgabepuffer voll (pro Zeile)
## und gib den Puffer aus, berücksichtige Wiederholungen

# init Zähler
let "AUSGABE = 0"
WDHZAEHLER=$WIEDERHOLUNG

# 'leerer' Puffer
unset ZEILEN_PUFFER
# es gibt $nummer-Adressen in der Liste
until [ $ADRESSE -gt $NUMMER ]
do
  # 4 Zeilen pro Adresse
  for i in $(seq 0 3)
  do 
    # Feld übertragen
    ZEILEN_PUFFER[$(( $AUSGABE *4 + $i))]="${ARRAY[$(( ($ADRESSE * 4) + $i))]}"
  done
  let "AUSGABE += 1"

  # auf Zeilenwechsel testen, 
  # wenn ja, Zeilenpuffer Ausgeben und neu initialisieren
  if [ $(( $AUSGABE % $SPALTEN )) -eq 0 ]
  then
    drucke_zeile ZEILEN_PUFFER
    unset ZEILEN_PUFFER
    let "AUSGABE = 0"
  fi
  
  # Wiederholung? wenn ja, dann n-mal die gleiche Adresse bearbeiten, 
  # sonst Adresse inkrementieren  
  if [ $WDHZAEHLER -gt 1 ]
  then
    let "WDHZAEHLER -=1"
  else
    let "ADRESSE += 1"
    WDHZAEHLER=$WIEDERHOLUNG
  fi
done

# unfertige Zeilen am Ende noch ausgeben...

if [ "$ZEILEN_PUFFER" ]
then 
  drucke_zeile ZEILEN_PUFFER
fi
# abschließende Linie
drucke_linie

#### eof ####

Optimierung ist recht einfach, die einlese-Schleife einfach mit der Ausgabe verheiraten... d.h. Ein Feld lesen und WDH-mal in den Ausgabepuffer schreiben, beim Zeilenwechsel ausgeben und fertig...

damit spart man sich noch das komplette Datei-Array

Anonymous · 13 Okt. 2005

Code:

aber warum exportierst Du "S"? das verwirrt mich direkt am Anfang...

Na klar, du findest aber auch immer gleich alles, :wink:

Wenn du da noch ein paar überflässige Zeilen findest, dann wirds vielleicht doch noch ein kompakter 4-Zeiler

robi

TeXpert · 13 Okt. 2005

so, das war dann ja doch unkomplizerter als gedacht

jetzt werden keine großen Arrays gebraucht, es wird immer nur eine Adresse nach der anderen gelesen und der Zeilenpuffer gefüllt, gleichzeitig werden jetzt auch leere Zeilen in der Eigabe ignoriert

Code:

#!/bin/bash

###########################################################
###
### Scriptspielerei
###
### -------------------------------------------------------
###
### (c) 2005, TeXpert
### für linux-club.de
### Referenz: http://www.linux-club.de/viewtopic.php?t=43489
### Version 0.3
###
### -------------------------------------------------------
###
### aufruf: scriptname Adressdatei Spaltenzahl wiederholungen
###
### Bemerkung: hardcoded für Anforderung von 4-zeiligen Adressen!
### Parametrisierung: FIELDWIDTH=23 beschreibt die Breite
### der Etiketten -> nach Belieben anpassen. (Anmerkung: 
### formatierte Textausgabe mit der Bash ist eine Quälerei ;) 
###
### -------------------------------------------------------
###
### Changelog
###  0.3 - Speicherplatz-optimierung, das große Array gibts nicht 
###        mehr, es reichen Array[0 ... 3] als Eingabepuffer und
###        Spalten*Array[0 ... 3] als Zeilenausgabepuffer
###  0.2 - erste kommentierte Version
###  0.1 - erste Version.
###########################################################


# pseudo-Constant
FIELDWIDTH=23


# Variablen
ADRESSEN_DATEI=
SPALTEN
WIEDERHOLUNG
NUMMER=0
ADRESS_ZEILE=0
ADRESSE=0
AUSGABE=0
declare -a ARRAY
declare -a ZEILEN_PUFFER
FIELD=$(printf "%${FIELDWIDTH}s" " ")


############################

function usage {
  echo "$1"
  echo "Aufruf: $0 adressendatei(DATEI) spaltenanzahl(INTEGER>0)
  wiederholungen(INTEGER>0)"
  exit 1
}

function drucke_linie {
  for i in $(seq $(( ($FIELDWIDTH +2) * $SPALTEN + 1)) )
  do 
    echo -n "-"
  done
  echo
}
function drucke_zeile {
  local line
  drucke_linie
  for z in $(seq 0 3)
  do
    line=""
    for s in $(seq 0 $(( $SPALTEN -1 )) )
    do
      curfield="${ZEILEN_PUFFER[$(($s * 4 + $z))]}$FIELD"
      curfield=${curfield:0:$FIELDWIDTH}
      if [ -n "$line" ]
      then
        line="$line$curfield| "
      else 
        line="| $curfield| "
      fi
    done
    echo "$line"
  done
}


############################


## Eingabevalidierung
# Anzahl
if [ "$#" -eq 3 ] 
then
  ADRESSEN_DATEI="$1"
  SPALTEN="$2"
  WIEDERHOLUNG="$3"
else
  usage "falsche Parameter!"
fi
# Datei
if [ ! -f "$ADRESSEN_DATEI" ]
then
  usage "Adressdatei existiert nicht!"
fi
# Zahlenbereiche
shopt -s extglob
if [[ $SPALTEN != +([1-9])*([0-9]) ]]
then
  usage "Spalten kein positiver Integer"
fi
if [[ $WIEDERHOLUNG != +([1-9])*([0-9]) ]]
then
  usage "Wiederholung kein positiver Integer"
fi
shopt -u extglob



## Jetzt Adressen parsen
## Annahme, alle Adressen haben 4 Zeilen, vgl. Musterdaten
## sonst muss hier noch mehr gewurstelt werden!
## Datensätze werden durch genau 1 Leerzeile getrennt!
## Weiterhin sollte am Anfang der Datei keine Leerzeile stehen
## sonst ensprechend vorbehandeln oder abfangen
##
## speichern in einem Array:
## a[i]=name
## a[i+1]=abteilung
## a[i+2]=strasse
## a[i+3]=ort/plz
##
## ein Adressdatensatz:
## a[nummer*4 + j] wobei $j \in \{0,\ldots,3\}$


# init Zähler
let "AUSGABE = 0"
WDHZAEHLER=$WIEDERHOLUNG
# 'leerer' Puffer
unset ZEILEN_PUFFER
# status für Leerzeilenerkennung
lastline=""

while read line
do
  # doppelte Leerzeilen wegfallen lassen
  if [ "$line" = "$lastline" ]; then continue;fi
  lastline="$line"
  # neuer Datensatz?  
  if [ -z "$line" ]
  then 
    let "ADRESS_ZEILE = 0"

    for WDH in $(seq 1 $WIEDERHOLUNG)
    do
      # in Ausgabepuffer übertragen
      for i in $(seq 0 3)
      do 
        # Feld übertragen
        ZEILEN_PUFFER[$(( $AUSGABE *4 + $i))]="${ARRAY[$i]}"
      done
      let "AUSGABE += 1"
      # auf Zeilenwechsel testen, 
      # wenn ja, Zeilenpuffer Ausgeben und neu initialisieren
      if [ $(( $AUSGABE % $SPALTEN )) -eq 0 ]
      then
        drucke_zeile ZEILEN_PUFFER
        unset ZEILEN_PUFFER
        let "AUSGABE = 0"
      fi      
    done
  	    
  else
    ARRAY[$ADRESS_ZEILE]="$line"
    let "ADRESS_ZEILE += 1"
  fi
done < $ADRESSEN_DATEI

# unfertige Zeilen am Ende noch ausgeben...

if [ "$ZEILEN_PUFFER" ]
then 
  drucke_zeile ZEILEN_PUFFER
fi
# abschließende Linie
drucke_linie

#### eof ####

Lord_Levithanius · 13 Okt. 2005

Feigheit vor dem Feind :lol:

Nein, im Ernst, freut mich, dass ich euch damit beschäftigen kann/konnte!
Ich werd mich am WE wohl mal richtig reinknien und es dann hoffentlich auch mal verstehen

Lord_Levithanius · 18 Okt. 2005

So, inzwischen sieht es bei mir gar nicht so schlecht aus, denke ich...
Ich habe nun doch meine Art der Adressenanordnung gewählt. Jetzt muss ich das nur noch mit der for-Schleife hinbekommen, da hakt es noch und ich weiß nicht wieso... Er soll einfach die function so oft durchgehen wie ich es ihm in der Variable $anz gesagt habe.

Hier mein Script:

Code:

#!/bin/bash

function ANZ
{
echo "Wie oft jede Adresse ausgeben?"
echo "1."
echo "2."
echo "3."
echo "4."
echo "5."
read anz 
}

ANZ

##############################
##############################

function BAHN
{
echo "Anzahl der Bahnen?"
echo "1."
echo "2."
echo "3."
echo "4."
read bahnen
}

##############################
##############################
function SCHLEIFE
{
zeile1="" 
zeile2=""
zeile3="" 
zeile4=""
Bahnmarker=0



for i in $anz 
do
read z1
read z2
read z3
read z4

Bahnmarker=+1
zeile1="$zeile1 $z1"
zeile2="$zeile2 $z2"
zeile3="$zeile3 $z3"
zeile4="$zeile4 $z4"

echo "$zeile1"
echo "$zeile2"
echo "$zeile3"
echo "$zeile4"
zeile1=""
zeile2=""
zeile3=""
zeile4=""
Bahnmarker=0
done < adr
}

##############################
##############################

if [ $anz -lt "1" -o $anz -gt "5" ]
then
ANZ
else
BAHN
fi


##############################
##############################

if [ $bahnen -lt "1" -o $bahnen -gt "4" ]
then
BAHN
else
SCHLEIFE "$bahnen"
fi

##############################
##############################

Anonymous · 18 Okt. 2005

Er soll einfach die function so oft durchgehen wie ich es ihm in der Variable $anz gesagt habe

Für eine solche Schleife bei der erst zum Zeitpunkt der Ausführung fest steht, wie oft sich durchlaufen wird, eigenet sich in der Bash eine while Schleife besser.

Code:

typeset -i ANZ         #Variable ANZ soll integer sein
ANZ=10                 #Variable ANZ wird 10

while [ $ANZ -gt 0 ]   #solange der Inhalt von ANZ größer als NULL
do                     #Schleifenbegin
echo $ANZ              #Ausgabe
ANZ=$ANZ-1             #ANZ=ANZ-1
done                   #Schleifenende

für eine For-schleife versuch mal sowas, aber der Befehl seq ist nicht unbedingt Standart auf jedem UNIX-System

Code:

for i in `seq 1 10`
do
echo $i
done

robi

TeXpert · 18 Okt. 2005

naja, wir reden hier von einem Bash-Script

und da ist seq dabei, so dass

Code:

for i in $(seq 1 $ANZ); do foobar; done

schon das macht was er will...

so ganz spontan wundere ich mich über andere Dinge

:arrow: 1.

Code:

SCHLEIFE "$bahnen"

d.h. Du übergibst eine Variable an die Funktion, aber in der Funktion Schleife passiert nix mit dem Parameter $1...

:arrow: 2.
in Deinem Adressbeispiel waren die Adressen durch Leerzeilen getrennt, hier werden stumpf immer 4 Zeilen nacheinander eingelesen -> keine Leerzeilen...

:arrow: 3.
die for-Schleife läuft über die Anzahlen wie oft eine Adresse gedruckt werden soll, und sooft werden jeweils 4 Zeilen aus der Datei ausgelesen...

Zusammenfassung: über den Bash-Stil kann man streiten

muss man nicht, aber ich denke Du solltest nochmal zu einem Pseudocode zurückkehren und Deinen Algorithmus beschreiben...

versuch das mal so in der Art:

Code:

wiederhole ANZAHL mal:
     gibt Zeilen 1, 2, 3 und 4 aus

lese 4 Zeilen ein

... dann wird dir Das Problem evtl. etwas klarer, wenn das dann steht, ist der Transfer in Bash einfach...

Lord_Levithanius · 18 Okt. 2005

Zu 1.:
Da hatte ich irgendetwas probiert, das "$bahnen" aber noch nicht wieder entfernt...

2.
Hmm...Ich hab aber Leerzeilen!

Und zu meinem Pseudocode will ich nicht schon wieder!

Ich werde es einfach mal mit robis Tip mit der while Schleife versuchen! Danke!

Lord_Levithanius · 19 Okt. 2005

So...Ein letztes Mal brauche ich eure Hilfe!

Es läuft alles super bis jetzt, leider weiß ich nicht wie ich das mit den Bahnen realisieren kann... Das ist ja jetzt nur noch ein Anordnungsproblem... Mir fehlt aber gerade die Logik

Hier das Script bis jetzt...

Code:

#!/bin/bash



function ANZ
{
echo "Wie oft jede Adresse ausgeben?"
echo "1."
echo "2."
echo "3."
echo "4."
echo "5."
read anz 
}

ANZ

##############################
##############################

function BAHN
{
echo "Anzahl der Bahnen?"
echo "1."
echo "2."
echo "3."
echo "4."
read bahnen
}

##############################
##############################

function SCHLEIFE
{
zeile1="" 
zeile2=""
zeile3="" 
zeile4=""
zeile5=""
BM=0

while read z1
 do
  read z2
  read z3
  read z4
  read dummy

while [ $BM != $anz ]
   do
  BM=`expr $BM + 1` 
  zeile1="$z1"
  zeile2="$z2"
  zeile3="$z3"
  zeile4="$z4"
  zeile5="$dummy"

  echo "$zeile1"
  echo "$zeile2"
  echo "$zeile3"
  echo "$zeile4"
  echo "$zeile5"
 done
BM=0

done < adr
}

##############################
##############################

if [ $anz -lt "1" -o $anz -gt "5" ]
then
ANZ
else
BAHN
fi


##############################
##############################

if [ $bahnen -lt "1" -o $bahnen -gt "4" ]
then
BAHN
else
SCHLEIFE
fi

##############################
##############################

Anonymous · 19 Okt. 2005

Das ist ziemlich schlechter Entwicklungsstiel, du hast den einfachen Teil des Problems gradlinienig durchprogrammiert, ohne ein Konzept zu haben, wie du den schwierigen Teil strukturieren willst.

Na ja, diesmal hab ich wohl noch einen Weg gefunden, wie du das noch einigemaßen dazwischenschieben kannst.

in deiner SCHLEIFE lässt du einen Zähler mitlaufen, der bei jeder zu schreibenden Adresse erhöht wird.

in den Zuweisungen der Zeilen schreibst du jeden neuen Eintrag an das Ende dieser Zeilen, und fügst anschließend noch ein Trennzeichen ein ( hier liegt das Potential das Programm irgendwie noch einigermaßen schön zu machen)

Dadurch entstehen lange Zeilen mit mehreren Einträgen.
Du errechnest mittels Modulo von deinem Zähler und der Anzahl der Spalten, wann die Anzahl der Spalten erreicht ist,

wenn das erreicht ist, werden die Zeilen geschrieben und anschließend geleert.
Also etwa so

Code:

funktion SCHLEIFE
{
ZAHLER=0
...........
............
while read
  
  while [ $BM != $anz ]
   do
    BM=`expr $BM + 1` 
    zeile1=$zeile1$z1 
    zeile1="$zeile1\t"
    zeile2.......... 


    ZAHLER=`expr $ZAHLER + 1`
    MODULO=`expr $ZAHLER % $bahnen`

   if [ $MODULO -eq 0 ]
     then 
       echo -e $zeile1
       zeile1=
       echo -e $zeile2
       .........

   fi
  done
......
done < adr
# Wenn die Zeilen hier nicht leer sein sollten, dann müssen sie an dieser
# Stelle noch einmal ausgegeben werden.
}

robi

TeXpert · 19 Okt. 2005

robi schrieb:
Das ist ziemlich schlechter Entwicklungsstiel, du hast den einfachen Teil des Problems gradlinienig durchprogrammiert, ohne ein Konzept zu haben, wie du den schwierigen Teil strukturieren willst.

*schulterzuck* das hab ich Ihm ja auch versucht klar zumachen... aber was willst Du machen?

Dadurch entstehen lange Zeilen mit mehreren Einträgen.
Du errechnest mittels Modulo von deinem Zähler und der Anzahl der Spalten, wann die Anzahl der Spalten erreicht ist,

wenn das erreicht ist, werden die Zeilen geschrieben und anschließend geleert.
Also etwa so

jepp die Idee klingt gut

(hab ich ja schließlich auch so gemacht

) auch wenn ich das jetzt nicht auf Sourcecode-Ebene debuggen werde....

nur ein Punkt:

Code:

    zeile1=$zeile1$z1

bitte quoten...

@Lord: mit diesem Entwicklungs-Stil wirst Du bei komplexeren Systemen hemmungslos auf die Fre**e fallen. Du musst vorher den Ablauf Deines Programms zumindest grob auf dem Papier (oder bei kleineren Dingen im Kopf haben) die technische Umsetzung in eine konkrete Sprache ist dann nur noch triviale Fleißarbeit... aber Softwareentwicklung ist der Schritt davor...

Du musst ja nicht gleich die UML-Keule schwingen, ein einfaches Flussdiagramm mit entsprechenden Kommentaren reicht, teilweise reicht sogar eine prosaische Beschreibung. Damit schlägst Du immer mehrere Fliegen tot:

1. was mache ich eigendlich,
2. wann mache ich was
3. was muss ich mir merken
4. welche Dinge muss ich mehrfach machen...

Wenn das klar ist, dann steht schon mal der grobe Ablauf des Programms...

Lord_Levithanius · 19 Okt. 2005

Ja, ich werde es mir merken! Ist ja auch eine gute Idee. Man muß nur bedenken, dass das scripten hier quasi mein erstes "programmieren" war/ist... Daher möchte ich mich auch noch einmal bei allen bedanken, die mir geholfen haben!

Ich bin mal gespannt, was ich jetzt für eine Aufgabe bekomme... Evtl. wollte er die gleich Aufgabe noch einmal in C machen :?
Und das letzte Projekt wird auf jeden Fall etwas mit VMWare und Netzwerk

Etikettendruck mit Script

TeXpert

Anonymous

Gast

Lord_Levithanius

TeXpert

Anonymous

Gast

regexer

TeXpert

Anonymous

Gast

TeXpert

Lord_Levithanius

Lord_Levithanius

Anonymous

Gast

TeXpert

Lord_Levithanius

Lord_Levithanius

Anonymous

Gast

TeXpert

Lord_Levithanius