Zeichenketten-Verarbeitung(2) AutoLisp

Im ersten Kapitel über die Bearbeitung von Zeichenketten haben wir uns bereits mit einer Grundausstattung von Funktionen versorgt, mit denen man Zeichenketten am Anfang und am Ende formatieren kann. Außerdem wurde ein Set von Funktionen für das Testen von Einzelzeichen vorgestellt.

Hier geht es jetzt weiter mit einem Bündel von neuen Lisp-Funktionen, mit denen man Zeichenketten durchsuchen sowie Teile aus Zeichenketten entfernen bzw. einfügen kann.

Unsere erste hier vorgestellte Funktion sucht eine Zeichenkette innerhalb einer anderen. Wird sie gefunden, wird die Position zurückgegeben, anderenfalls ist der Rückgabewert nil. Der Suchstring kann ein einzelnes Zeichen sein, er kann aber auch aus mehreren Zeichen bestehen. Gleich dazu gibt es eine Variante, die nicht zwischen Groß- und Kleinschreibung unterscheidet

(defun str-pos(str c / i l ls lc)
  (setq i 1)
  (setq ls(strlen str))
  (setq lc(strlen c))
  (setq l(1+(- ls lc)))
  (while(and(<= i l)(/=(substr str i lc)c))
    (setq i(1+ i))
  )
  (if(<= i l)i)
)

(defun str-ipos(str c / )
  (str-pos(strcase str)(strcase c))
)

Anwendungsbeispiele:

(str-pos "c:\\root" "\\") => 3
(str-ipos "Tintenfisch" "Fisch") => 7

Die nächste Variante arbeitet wieder mit einem Set von Zeichen anstelle eines Suchstrings, wie wir das bereits aus dem vorigen Kapitel über Strings kennen:

(defun str-posset(str cset / i)
  (setq i 1)
  (while
    (and
      (<= i(strlen str))
      (not(str-pos cset(substr str i 1)))
    )
    (setq i(1+ i))
  )
  (if(> i(strlen str))nil i)
)

Anwendungsbeispiel:

(str-posset "Hier wurde geändert" "ÄÖÜäöüß") => 13

Die nachfolgende Funktion fügt eine Zeichenkette an der angegebenen Position in einen anderen String ein:

(defun str-insert(str neu pos / )
  (strcat
    (substr str 1(1- pos))
    neu
    (substr str pos)
  )
)

Anwendungsbeispiel:

(str-insert "Dies ist ein Text" "anderer " 14)
          => "Dies ist ein anderer Text"

Und die Funktion tut in etwa das Gegenteil: Sie entfernt an der angegebenen Position eine bestimmte Menge von Zeichen:

(defun str-remove(str pos n / )
  (strcat
    (substr str 1(1- pos))
    (substr str(+ pos n))
  )
)

Anwendungsbeispiel:

(str-remove "Eisenbahn" 4 2)  => "Eisbahn"

Ähnlich wie (subst ...) bei den Listen ersetzt die folgende Funktion einen Teilstring innerhalb eines Strings durch einen anderen String. Natürlich kann es sich hier um einzelne Zeichen oder auch Folgen aus Zeichen handeln:

(defun str-subst(str neu alt / i la str2)
  (setq i 1)
  (setq la(strlen alt))
  (setq str2 "")
  (while(<= i(strlen str))
    (if
      (=(substr str i la)alt)
      (progn
        (setq str2(strcat str2 neu))
        (setq i(+ i la))
      )
      (progn
        (setq str2(strcat str2(substr str i 1)))
        (setq i(1+ i))
      )
    )
  )
  str2
)

Anwendungsbeispiele:

(str-subst "c:/dir/subdir/file.ext" "\\" "/")
          =>  "c:\\dir\\subdir\\file.ext"

Die nächste Funktion zählt, wie oft das Token tok im String str vorkommt. Die zweite Version arbeitet wieder unabhängig von der Groß- und Kleinschreibung:

(defun str-count(str tok / res)
  (setq res 0)
  (while(>(strlen str)0)
    (if(=(str-pos str tok)1)
      (progn
        (setq res(1+ res))
        (setq str(substr str(1+(strlen tok))))
      )
      (progn
        (setq str(substr str 2))
      )
    )
  )
  res
)

(defun str-icount(str tok / )'(
  (str-count(strcase str)(strcase tok))
)

Anwendungsbeispiele:

(str-count "Abakadabra" "a") => 4
(str-icount "Abakadabra" "a") => 5

Im dritten Kapitel zum Thema Strings werden wir uns dann mit dem Zerlegen von Strings anhand von Trennzeichen befassen. Natürlich kommt auch das Gegenteil nicht zu kurz, nämlich das Zusammenfügen von Strings.