Die Zwischenablage ist ein praktisches Werkzeug, wenn es darum geht, Texte zu kopieren und an anderer Stelle wieder einzufügen. Das ist insbesondere sinnvoll, wenn es sich um umfangreichere Texte handelt. Dabei können wir Funktionen programmieren, die den markierten Text in die Zwischenablage kopieren und solche, die den Inhalt der Zwischenablage als Funktionsergebnis liefern. In diesem Artikel schauen wir uns an, wo man solche Funktionen sinnvoll einsetzen kann und wie sie programmiert werden.<\/b><\/p>\n
Texte in die Zwischenablage einfügen<\/h2>\n
In unserer Praxis konnten wir Funktionen zum Kopieren von Texten in die Zwischenablage hauptsächlich dort nutzen, wo eine Ausgabe in den Direktbereich zu umfangreich war, als dort komplett dargestellt zu werden. Das heißt, wir lassen uns beispielsweise das Ergebnis des Aufrufs einer Rest-API im Direktbereich ausgeben und stellen dann beim Scrollen zum Beginn der Ausgabe fest, dass ein Teil abgeschnitten wurde. Hier gibt es dann zwei Möglichkeiten:<\/p>\n
Und genau für letzteren Zweck benötigen eine Routine, welche die Rückgabe einer Funktion oder auch den Inhalt einer Variablen in die Zwischenablage kopiert.<\/p>\n
Der umgekehrte Anwendungsfall tritt auf, wenn wir den Inhalte der Zwischenablage in eine Variable füllen oder diesen direkt einer Funktion zur weiteren Verarbeitung zuweisen wollen.<\/p>\n
Auch hier ein Beispiel: Wir holen aus der Benutzeroberfläche beispielsweise von eBay oder einer anderen Rest-API ein Token, das oft so lang ist, dass man es in einer Konstanten nicht in einer einzelnen Zeile verarbeiten kann (Codezeilen in VBA haben eine natürliche Grenze, und zwar 1.024 Zeichen). Dann müsste man dieses wie folgt auf mehrere Zeichen umbrechen:<\/p>\n
Public <\/span>Const cStrBeispiel = \"1234567890\" _\r\n & \"1234567890123456789012345678901234567890\" _\r\n & \"1234567890123456789012345678901234567890\" _\r\n & \"1234567890123456789012345678901234567890\" <\/pre>\nDas macht keinen Spaß und vor allem ist es fehleranfällig, weil man hier schnell mal ein Zeichen zu viel oder zu wenig hat.<\/p>\n
Also könnten wir, wenn wir das Token aus der Zwischenablage direkt verarbeiten könnten, direkt die Hilfsfunktion aus Listing 1 für diesen Zweck nutzen. Die Funktion nimmt zwei Parameter entgegen. Der erste erwartet den Namen der zu definierenden Konstanten, der zweite die Anzahl der Zeichen je Zeile für die Konstante.<\/p>\n
Public Function <\/span>ZwischenablageInKonstante(strKonstante As String<\/span>, lngZeichen As Long<\/span>) As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n strTemp = AusZwischenablage\r\n strCode = \"Public Const \" & strKonstante & \" As String<\/span> = \"\r\n strCode = strCode & \"\"\"\" & Left<\/span>(strTemp, lngZeichen) & \"\"\" _\" & vbCrLf<\/span>\r\n strTemp = Mid<\/span>(strTemp, lngZeichen)\r\n lngLaenge = Len<\/span>(strTemp)\r\n Do While<\/span> Not<\/span> lngLaenge = 0\r\n strCode = strCode & \" & \"\"\" & Left<\/span>(strTemp, lngZeichen) & \"\"\" _\" & vbCrLf<\/span>\r\n strTemp = Mid<\/span>(strTemp, lngZeichen)\r\n lngLaenge = Len<\/span>(strTemp)\r\n Loop<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strCode) = 0 Then<\/span>\r\n strCode = Left<\/span>(strCode, Len<\/span>(strCode) - 4)\r\n End If<\/span>\r\n ZwischenablageInKonstante = strCode\r\nEnd Function<\/span><\/pre>\nListing 1: Funktion zum Zerlegen einer Zeichenkette in eine mehrzeilige Konstante<\/span><\/b><\/p>\nDie Funktion holt mit der später noch zu beschreibenden Funktion AusZwischenablage <\/b>den Inhalt der Zwischenablage in die Variable strTemp<\/b>. Dann stellt sie den ersten Teil des Codes der ersten Zeile zusammen, der nur aus der Deklaration der eigentlichen Konstanten besteht.<\/p>\n
Anschließend fügt sie die ersten Zeichen entsprechend des Wertes des Parameters lngZeichen <\/b>zusammen, indem sie mit der Left<\/b>-Funktion die entsprechende Teilzeichenkette ausliest. Damit diese Zeichen nicht nochmals verwendet werden, verkürzen wir die Zeichenkette aus strTemp<\/b> vorne um die entsprechende Anzahl Zeichen. Danach gehen wir in eine Do While<\/b>-Schleife, die wir erst verlassen, wenn die Länge der Zeichenkette in strTemp <\/b>gleich 0 <\/b>ist – also wenn alle Teilzeichenketten in die Variable strCode <\/b>gelangt sind und entsprechend vorn aus strTemp <\/b>herausgeschnitten wurden.<\/p>\n
Diese Schritte führen wir für alle verbleibenden Zeichen durch und erhalten beispielsweise ein Ergebnis wie in Bild 1. Der Code überschreitet so sicher nicht die zulässige Höchstanzahl an Zeichen pro Zeile.<\/p>\n
![\"Ergebnis](\"..\/fileadmin\/_temp_\/2025_01\/pic_458_001.png\")
<\/p>\n
Bild 1: Ergebnis des Aufteilens der Zwischenablage in eine mehrzeilige Konstante<\/span><\/b><\/p>\nFunktionen zum Einlesen in und zum Ausgeben aus der Zwischenablage<\/h2>\n
Damit kommen wir zu den eigentlichen Funktionen. Für diese benötigen wir einige API-Funktionen (siehe Listing 2). Im ersten Schritt schauen wir uns die Funktion zum Schreiben von Texten in die Zwischenablage an.<\/p>\n
#If Win64 Then\r\n '' 64-Bit Deklarationen\r\n Private <\/span>Declare PtrSafe Function GlobalUnlock Lib \"kernel32\" (ByVal hMem As Long<\/span>Ptr) As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function GlobalLock Lib \"kernel32\" (ByVal hMem As Long<\/span>Ptr) As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Function GlobalAlloc Lib \"kernel32\" (ByVal wFlags As Long<\/span>, ByVal dwBytes As Long<\/span>) _\r\n As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Function CloseClipboard Lib \"user32\" () As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function OpenClipboard Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr) As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function EmptyClipboard Lib \"user32\" () As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function lstrcpyW Lib \"kernel32\" (ByVal lpString1 As Long<\/span>Ptr, ByVal lpString2 As Long<\/span>Ptr) _\r\n As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Function SetClipboardData Lib \"user32\" (ByVal wFormat As Long<\/span>, ByVal hMem As Long<\/span>Ptr) _\r\n As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Function GetClipboardData Lib \"user32\" (ByVal wFormat As Long<\/span>) As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Function IsClipboardFormatAvailable Lib \"user32\" (ByVal wFormat As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function GlobalSize Lib \"kernel32\" (ByVal hMem As Long<\/span>Ptr) As Long<\/span>\r\n Private <\/span>Declare PtrSafe Function GlobalFree Lib \"kernel32\" (ByVal hMem As Long<\/span>Ptr) As Long<\/span>Ptr\r\n Private <\/span>Declare PtrSafe Sub CopyMemoryByAddr Lib \"kernel32\" Alias \"RtlMoveMemory\" (ByVal Destination As Long<\/span>Ptr, _\r\n ByVal Source As Long<\/span>Ptr, ByVal Length As Long<\/span>)\r\n#Else\r\n '' 32-Bit Deklarationen\r\n Private <\/span>Declare Function GlobalUnlock Lib \"kernel32\" (ByVal hMem As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function GlobalLock Lib \"kernel32\" (ByVal hMem As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function GlobalAlloc Lib \"kernel32\" (ByVal wFlags As Long<\/span>, ByVal dwBytes As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function CloseClipboard Lib \"user32\" () As Long<\/span>\r\n Private <\/span>Declare Function OpenClipboard Lib \"user32\" (ByVal hWnd As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function EmptyClipboard Lib \"user32\" () As Long<\/span>\r\n Private <\/span>Declare Function lstrcpyW Lib \"kernel32\" (ByVal lpString1 As Long<\/span>, ByVal lpString2 As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function SetClipboardData Lib \"user32\" (ByVal wFormat As Long<\/span>, ByVal hMem As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function GetClipboardData Lib \"user32\" (ByVal wFormat As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function IsClipboardFormatAvailable Lib \"user32\" (ByVal wFormat As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function GlobalSize Lib \"kernel32\" (ByVal hMem As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Function GlobalFree Lib \"kernel32\" (ByVal hMem As Long<\/span>) As Long<\/span>\r\n Private <\/span>Declare Sub CopyMemoryByAddr Lib \"kernel32\" Alias \"RtlMoveMemory\" (ByVal Destination As Long<\/span>, _\r\n ByVal Source As Long<\/span>, ByVal Length As Long<\/span>)\r\n#End If<\/pre>\nListing 2: API-Deklarationen für Funktionen rund um die Zwischenablage<\/span><\/b><\/p>\nTexte in die Zwischenablage schreiben<\/h2>\n
Die Funktion Inzwischenablage<\/b> übernimmt genau diese Aufgabe (siehe Listing 3): Sie erwartet als Parameter eine Zeichenkette, also eine beliebige Zeichenfolge, die später über Strg + V<\/b> oder andere Clipboard-Funktionen in eine andere Anwendung eingefügt werden kann. Die Besonderheit dabei ist, dass wir hier bewusst auf das Unicode-Format setzen, also die Daten in der Zwischenablage als CF_UNICODETEXT <\/b>speichern. Das hat den Vorteil, dass auch Sonderzeichen, Emojis und Umlaute sauber übergeben werden – ganz im Gegensatz zur älteren CF_TEXT<\/b>-Variante, bei der häufig verstümmelte oder unvollständige Zeichenfolgen herauskamen.<\/p>\nPublic <\/span>Const GHND = &H42\r\nPublic <\/span>Const CF_UNICODETEXT = 13\r\nFunction <\/span>Inzwischenablage(ByVal MyString As String<\/span>)\r\n#If Win64 Then\r\n Dim <\/span>hGlobalMemory As Long<\/span>Ptr\r\n Dim <\/span>lpGlobalMemory As Long<\/span>Ptr\r\n Dim <\/span>hClipMemory As Long<\/span>Ptr\r\n#Else\r\n Dim <\/span>hGlobalMemory As Long<\/span>\r\n Dim <\/span>lpGlobalMemory As Long<\/span>\r\n Dim <\/span>hClipMemory As Long<\/span>\r\n#End If\r\n Dim <\/span>X As Long<\/span>\r\n hGlobalMemory = GlobalAlloc(GHND, (Len<\/span>(MyString) + 1) * 2)\r\n lpGlobalMemory = GlobalLock(hGlobalMemory)\r\n Call<\/span> lstrcpyW(lpGlobalMemory, StrPtr(MyString))\r\n Call<\/span> GlobalUnlock(hGlobalMemory)\r\n If <\/span>OpenClipboard(0&) = 0 Then<\/span>\r\n MsgBox<\/span> \"Konnte Zwischenablage nicht öffnen.\", vbExclamation\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Call<\/span> EmptyClipboard\r\n hClipMemory = SetClipboardData(CF_UNICODETEXT, hGlobalMemory)\r\n Call<\/span> CloseClipboard\r\nEnd Function<\/span><\/pre>\nListing 3: Funktion zum Einfügen von Text in die Zwischenablage<\/span><\/b><\/p>\nDie Funktion verwendet Windows-API-Funktionen wie GlobalAlloc<\/b>, GlobalLock<\/b>, OpenClipboard <\/b>und SetClipboardData<\/b>.<\/p>\n
All diese Funktionen sind je nach eingesetzter Office- beziehungsweise VBA-Version als 32-Bit- oder 64-Bit-Deklarationen definiert. Damit die Funktion in beiden Umgebungen läuft, unterscheiden wir nur die Variablentypen und API-Deklarationen über einen #If Win64<\/b>-Block – der übrige Code ist vollständig gemeinsam nutzbar.<\/p>\n
Das bedeutet für die Praxis: Mit Inzwischenablage strMeinText <\/b>lässt sich in jedem VBA-Projekt schnell ein längerer Text (zum Beispiel eine JSON-Antwort einer API, Log-Ausgabe, Datenbankabfrage und so weiter) in die Zwischenablage kopieren – unabhängig davon, ob Access, Excel oder Word als Host verwendet wird.<\/p>\nTexte aus der Zwischenablage lesen<\/h2>\n
Die Gegenfunktion trägt den Namen AusZwischenablage <\/b>und ist im Prinzip die Umkehrung der obigen Funktion (siehe Listing 4).<\/p>\nFunction <\/span>AusZwischenablage() As String<\/span>\r\n#If Win64 Then\r\n Dim <\/span>hClipMemory As Long<\/span>Ptr\r\n Dim <\/span>lpClipMemory As Long<\/span>Ptr\r\n#Else\r\n Dim <\/span>hClipMemory As Long<\/span>\r\n Dim <\/span>lpClipMemory As Long<\/span>\r\n#End If\r\n Dim <\/span>Size As Long<\/span>\r\n Dim <\/span>Buffer As String<\/span>\r\n Dim <\/span>posNull As Long<\/span>\r\n If <\/span>IsClipboardFormatAvailable(CF_UNICODETEXT) = 0 Then<\/span> Exit Function<\/span>\r\n If <\/span>OpenClipboard(0&) Then<\/span>\r\n hClipMemory = GetClipboardData(CF_UNICODETEXT)\r\n If <\/span>hClipMemory <> 0 Then<\/span>\r\n lpClipMemory = GlobalLock(hClipMemory)\r\n If <\/span>lpClipMemory <> 0 Then<\/span>\r\n Size = GlobalSize(hClipMemory)\r\n If <\/span>Size > 0 Then<\/span>\r\n Buffer = String$(Size \\ 2, vbNullChar)\r\n CopyMemoryByAddr StrPtr(Buffer), lpClipMemory, Size\r\n posNull = InStr<\/span>(Buffer, vbNullChar)\r\n If <\/span>posNull > 0 Then<\/span>\r\n Buffer = Left$(Buffer, posNull - 1)\r\n End If<\/span>\r\n AusZwischenablage = Buffer\r\n End If<\/span>\r\n Call<\/span> GlobalUnlock(hClipMemory)\r\n End If<\/span>\r\n End If<\/span>\r\n Call<\/span> CloseClipboard\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nListing 4: Funktion zum Auslesen von Text aus der Zwischenablage<\/span><\/b><\/p>\nAuch sie verwendet die genannten Windows-API-Funktionen, diesmal jedoch GetClipboardData<\/b>, GlobalLock<\/b>, GlobalSize <\/b>und CopyMemory<\/b>, um den Inhalt der Zwischenablage auszulesen und in eine String<\/b>-Variable zu überführen.<\/p>\n
Ein wichtiger Aspekt ist dabei erneut das Format: Wir greifen gezielt auf den Inhalt der Zwischenablage im Unicode-Textformat (CF_UNICODETEXT<\/b>) zu. Das stellt sicher, dass auch Inhalte verarbeitet werden können, die Sonderzeichen enthalten – was bei Tokens, XML-Dateien oder UTF-8-kodierten Inhalten in der Praxis ständig vorkommt.<\/p>\n
Ein häufiges Anwendungsszenario ist das Auslesen eines Werts, den man zuvor aus einer externen Quelle (zum Beispiel einer Webseite, einem Editor oder einer Web-API) kopiert hat. In der Praxis sieht das dann so aus:<\/p>\n
Dim <\/span>strToken As String<\/span>\r\nstrToken = AusZwischenablage<\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Diese Funktionen zum Einfügen von Texten in die Zwischenablagen und zum Auslesen von Texten aus der Zwischenablage setzen wir beispielsweise im Artikel ein.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die Zwischenablage ist ein praktisches Werkzeug, wenn es darum geht, Texte zu kopieren und an anderer Stelle wieder einzufügen. Das ist insbesondere sinnvoll, wenn es sich um umfangreichere Texte handelt. Dabei können wir Funktionen programmieren, die den markierten Text in die Zwischenablage kopieren und solche, die den Inhalt der Zwischenablage als Funktionsergebnis liefern. In diesem Artikel schauen wir uns an, wo man solche Funktionen sinnvoll einsetzen kann und wie sie programmiert werden.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012025,662025,44000027,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000458","post","type-post","status-publish","format-standard","hentry","category-66012025","category-662025","category-Excel_programmieren","category-VBAProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000458","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000458"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000458\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000458"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000458"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000458"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000458"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}