Im Beitrag „Reguläre Ausdrücke in VBA, Teil 2: Praxis-Rezepte“ (www.access-im-unternehmen.de\/1617) haben wir mit einem regulären Ausdruck geprüft, ob eine IBAN formal richtig aufgebaut ist. Das schützt aber nur vor groben Schnitzern – ein Zahlendreher in der Kontonummer geht anstandslos durch. Genau dafür gibt es Prüfziffern: eine oder zwei zusätzliche Stellen, aus den übrigen berechnet, die beim Vertippen fast immer nicht mehr passen. Dieser Beitrag zeigt die Verfahren hinter IBAN, ISBN, GTIN, Kreditkartennummer und Umsatzsteuer-Identifikationsnummer und liefert sie als fertige Funktionen, die Sie in Formularen und Abfragen einsetzen können.<\/b><\/p>\n
Was eine Prüfziffer leistet – und was nicht<\/h2>\n
Eine Prüfziffer enthält redundante Information. Sie enthält keine neue Information, sondern bildet in verdichteter Form ab, was in den übrigen Stellen bereits enthalten ist. Weicht sie ab, war ein Fehler im Spiel.<\/p>\n
Die gängigen Verfahren erkennen einzelne falsch eingegebene Ziffern und viele typische Zahlendreher. Welche Fehler garantiert erkannt werden, hängt jedoch vom jeweiligen Verfahren ab: Das für die GTIN verwendete Modulo-10-Verfahren lässt beispielsweise bestimmte Vertauschungen benachbarter Ziffern unentdeckt, während die Modulo-11- und Modulo-97-Verfahren hier strenger sind.<\/p>\n
Was eine Prüfziffer dagegen nicht<\/b> leistet: Sie sagt nichts darüber aus, ob es das Konto, das Buch oder die Firma tatsächlich gibt. Eine IBAN mit korrekter Prüfziffer kann problemlos frei erfunden sein.<\/p>\n
Und sie ersetzt auch nicht die Formatprüfung – beide Schritte gehören zusammen.<\/p>\n
So unterschiedlich die Verfahren im Detail sind, der Ablauf ist immer derselbe. Erst wird der Wert normalisiert, dann die Struktur geprüft und zuletzt gerechnet. Beim Normalisieren dürfen allerdings nur die für den jeweiligen Nummerntyp zulässigen Trennzeichen entfernt werden<\/b>. Alle anderen Zeichen müssen zur Ablehnung der Eingabe führen.<\/p>\n
Das klingt nach Erbsenzählerei, ist aber sicherheitsrelevant. Eine Funktion, die unterschiedslos jedes nicht alphanumerische Zeichen wegwirft, würde die Eingabe DE89!3704 0044 0532 0130 00<\/b> klaglos als gültige IBAN durchwinken – das Ausrufezeichen verschwindet ja vor der Prüfung. Für eine Validierung ist das zu großzügig.<\/p>\n
Wir trennen deshalb in zwei Schritte. Zuerst eine Funktion, die tatsächlich nur Ziffern und Großbuchstaben übrig lässt – siehe Listing 1.<\/p>\n
Public Function <\/span>NurAlphanumerisch(ByVal strWert As String<\/span>) As String<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>strZeichen As String<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n For lngPos = 1 To Len<\/span>(strWert)\r\n strZeichen = UCase(Mid<\/span>(strWert, lngPos, 1))\r\n Select Case Asc(strZeichen)\r\n Case <\/span>48 To 57, 65 To 90\r\n strErgebnis = strErgebnis & strZeichen\r\n End Select<\/span>\r\n Next<\/span> lngPos\r\n NurAlphanumerisch = strErgebnis\r\nEnd Function<\/span><\/pre>\nListing 1: Entfernen aller Trenn- und Sonderzeichen<\/span><\/b><\/p>\nEin Aufruf im Direktbereich zeigt, was die Funktion tut:<\/p>\n
Debug.Print<\/span> NurAlphanumerisch(\"DE89 3704 0044\")\r\nDebug.Print<\/span> NurAlphanumerisch(\"0-8044-2957-x\")<\/pre>\nErgebnis:<\/p>\n
DE8937040044\r\n080442957X<\/pre>\nDie Prüfung über die ASCII-Codes der Zeichen statt über einen Vergleich der Buchstaben ist beabsichtigt. Unter Option Compare Database<\/b> würde ein Ausdruck wie strZeichen >= „A“<\/b> auch Umlaute einschließen, was hier unerwünscht wäre.<\/p>\n
Und darüber liegt eine zweite Funktion, die zuerst kontrolliert, ob im Rohwert überhaupt nur erlaubte Zeichen vorkommen. Ist das nicht der Fall, liefert sie einen Leerstring zurück – und jede nachfolgende Strukturprüfung schlägt fehl:<\/p>\n
Private Function <\/span>Bereinigt( _\r\n ByVal strWert As String<\/span>, _\r\n ByVal strErlaubt As String<\/span>) As String<\/span>\r\n If <\/span>Not<\/span> RegExTest(strWert, strErlaubt) Then<\/span> Exit Function<\/span>\r\n Bereinigt = NurAlphanumerisch(strWert)\r\nEnd Function<\/span><\/pre>\nDer Unterschied wird sofort sichtbar. Die eckigen Klammern im Aufruf dienen nur dazu, den Leerstring im Direktbereich erkennbar zu machen:<\/p>\n
Debug.Print<\/span> \"[\" & Bereinigt(\"DE89 3704\", _\r\n \"^[A-Z0-9 ]+$\") & \"]\"\r\nDebug.Print<\/span> \"[\" & Bereinigt(\"DE89!3704\", _\r\n \"^[A-Z0-9 ]+$\") & \"]\"<\/pre>\nErgebnis:<\/p>\n
[DE893704]\r\n[]<\/pre>\nWelche Trennzeichen erlaubt sind, entscheidet jedes Verfahren für sich: bei der IBAN nur Leerzeichen, bei ISBN und GTIN zusätzlich Bindestriche. Die Funktion RegExTest<\/b> stammt aus dem vorigen Beitrag dieser Reihe; wer sie nicht zur Hand hat, kann die Vorprüfung auch mit einer Schleife über die Zeichen erledigen.<\/p>\nRechnen ohne Überlauf: das Modulo-97-Verfahren<\/h2>\n
Die IBAN verwendet ein Verfahren, das auf den ersten Blick in VBA gar nicht umsetzbar scheint. Man ersetzt jeden Buchstaben durch eine zweistellige Zahl, hängt die ersten vier Zeichen hinten an und bildet vom Ergebnis den Rest bei der Division durch 97. Das Problem: Bei einer deutschen IBAN entsteht dabei eine Zahl mit über 20 Stellen.<\/p>\n
Ein Long<\/b> reicht nur bis 2.147.483.647, und ein Double<\/b> kann sehr lange Ganzzahlen nicht mehr zifferngenau darstellen.<\/p>\n
Der Ausweg ist so einfach wie elegant. Statt die ganze Zahl zu bilden, arbeiten wir uns Ziffer für Ziffer vor und nehmen nach jedem Schritt den Rest. Weil dieser höchstens 96 sein kann, bleibt der Zwischenwert immer unter 970 und passt damit mühelos in ein Long<\/b> (siehe Listing 2).<\/p>\nPublic Function <\/span>Modulo97(ByVal strZiffern As String<\/span>) As Long<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>lngRest As Long<\/span>\r\n For lngPos = 1 To Len<\/span>(strZiffern)\r\n lngRest = (lngRest * 10 + CLng(Mid<\/span>(strZiffern, lngPos, 1))) Mod<\/span> 97\r\n Next<\/span> lngPos\r\n Modulo97 = lngRest\r\nEnd Function<\/span><\/pre>\nListing 2: Rest der Division durch 97 für beliebig lange Zahlen<\/span><\/b><\/p>\nDass die Funktion auch mit Zahlen umgeht, die kein VBA-Datentyp mehr fassen kann, lässt sich leicht nachprüfen:<\/p>\n
Debug.Print<\/span> Modulo97(\"100\")\r\nDebug.Print<\/span> Modulo97(\"12345678901234567890\")<\/pre>\nErgebnis:<\/p>\n
3\r\n3<\/pre>\nDieses schrittweise Vorgehen lässt sich auf jeden Modulus übertragen – die Funktion selbst ist allerdings fest auf 97 programmiert.<\/p>\n
Merken Sie sich das Muster unabhängig vom Thema Prüfziffern: Es ist immer dann Gold wert, wenn Sie mit Zahlen jenseits der VBA-Grenzen hantieren müssen.<\/p>\n
Rezept 1: Die IBAN<\/h2>\n
Nun die Umsetzung der Zeichen in Ziffern. Buchstaben werden dabei durch ihre Position im Alphabet plus 9 ersetzt, also A durch 10 bis Z durch 35. Da der Zeichencode von A bei 65 liegt, genügt eine Subtraktion von 55 (siehe Listing 3).<\/p>\n
Public Function <\/span>IbanInZiffern(ByVal strIban As String<\/span>) As String<\/span>\r\n Dim <\/span>strUmgestellt As String<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>lngCode As Long<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n ' Die ersten vier Zeichen wandern ans Ende\r\n strUmgestellt = Mid<\/span>(strIban, 5) & Left<\/span>(strIban, 4)\r\n For lngPos = 1 To Len<\/span>(strUmgestellt)\r\n lngCode = Asc(Mid<\/span>(strUmgestellt, lngPos, 1))\r\n If <\/span>lngCode >= 48 And lngCode <= 57 Then<\/span>\r\n strErgebnis = strErgebnis & Chr(lngCode)\r\n Else<\/span>\r\n strErgebnis = strErgebnis & CStr(lngCode - 55)\r\n End If<\/span>\r\n Next<\/span> lngPos\r\n IbanInZiffern = strErgebnis\r\nEnd Function<\/span><\/pre>\nListing 3: Umsetzen der IBAN in eine reine Ziffernfolge<\/span><\/b><\/p>\nDamit lässt sich das Verfahren Schritt für Schritt nachvollziehen. Das D wird zu 13, das E zu 14, und der Rest muss am Ende 1 ergeben:<\/p>\n
Debug.Print<\/span> IbanInZiffern(\"DE89370400440532013000\")\r\nDebug.Print<\/span> Modulo97( _\r\n IbanInZiffern(\"DE89370400440532013000\"))\r\n370400440532013000131489\r\n1<\/pre>\nDamit ist die eigentliche Prüffunktion kurz. Der Rest muss am Ende genau 1 betragen – das ist die Kernaussage des Verfahrens nach ISO 7064, das wir in der Funktion IstIban <\/b>abgebildet haben (siehe Listing 4).<\/p>\nPublic Function <\/span>IstIban(ByVal strIban As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strWert As String<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n ' Erlaubt sind nur Buchstaben, Ziffern, Leerzeichen\r\n strWert = Bereinigt(strIban, \"^[A-Z0-9 ]+$\")\r\n ' Grundstruktur pruefen\r\n If <\/span>Not<\/span> RegExTest(strWert, \"^[A-Z]{2}\\d{2}[A-Z0-9]{11,30}$\") Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n ' Land muss bekannt und die Laenge korrekt sein\r\n lngLaenge = IbanLaenge(Left<\/span>(strWert, 2))\r\n If <\/span>lngLaenge = 0 Then<\/span> Exit Function<\/span>\r\n If <\/span>Len<\/span>(strWert) <> lngLaenge Then<\/span> Exit Function<\/span>\r\n IstIban = (Modulo97(IbanInZiffern(strWert)) = 1)\r\nEnd Function<\/span><\/pre>\nListing 4: Prüfen einer IBAN<\/span><\/b><\/p>\nVier Aufrufe zeigen, welche Fehler die Funktion abfängt:<\/p>\n
Debug.Print<\/span> IstIban(\"DE89 3704 0044 0532 0130 00\")\r\nDebug.Print<\/span> IstIban(\"DE89 3704 0044 0532 0130 01\")\r\nDebug.Print<\/span> IstIban(\"DE89!3704 0044 0532 0130 00\")\r\nDebug.Print<\/span> IstIban(\"XX89 3704 0044 0532 0130 00\")\r\nWahr\r\nFalsch\r\nFalsch\r\nFalsch<\/pre>\nDer zweite Aufruf scheitert an der Prüfziffer, der dritte am eingeschmuggelten Ausrufezeichen und der vierte am unbekannten Ländercode.<\/p>\n
Die Längenprüfung ist wichtiger, als sie aussieht. Ohne sie würde eine deutsche IBAN, bei der eine Ziffer fehlt, unter Umständen trotzdem als gültig durchgehen, weil das Modulo-Verfahren die Länge nicht kennt. Die Zuordnung von Land zu Länge erledigt eine schlichte Fallunterscheidung, die wir in der Funktion IbanLaenge<\/b> erledigen (siehe Listing 5).<\/p>\nPublic Function <\/span>IbanLaenge(ByVal strLand As String<\/span>) As Long<\/span>\r\n Select Case UCase(strLand)\r\n Case <\/span>\"DE\", \"GB\", \"BG\": IbanLaenge = 22\r\n Case <\/span>\"AT\", \"LT\", \"LU\", \"EE\": IbanLaenge = 20\r\n Case <\/span>\"CH\", \"LI\", \"HR\": IbanLaenge = 21\r\n Case <\/span>\"FR\", \"IT\", \"GR\": IbanLaenge = 27\r\n Case <\/span>\"ES\", \"SE\", \"CZ\", \"SK\", \"RO\": IbanLaenge = 24\r\n Case <\/span>\"NL\", \"DK\", \"FI\": IbanLaenge = 18\r\n Case <\/span>\"BE\": IbanLaenge = 16\r\n Case <\/span>\"NO\": IbanLaenge = 15\r\n Case <\/span>\"SI\": IbanLaenge = 19\r\n Case <\/span>\"PT\": IbanLaenge = 25\r\n Case <\/span>\"TR\": IbanLaenge = 26\r\n Case <\/span>\"PL\", \"HU\": IbanLaenge = 28\r\n Case Else<\/span>: IbanLaenge = 0\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nListing 5: Ermitteln der Länge einer IBAN<\/span><\/b><\/p>\nDie Funktion liefert zum Beispiel folgende Ergebnisse:<\/p>\n
Debug.Print<\/span> IbanLaenge(\"DE\")\r\nDebug.Print<\/span> IbanLaenge(\"CH\")\r\nDebug.Print<\/span> IbanLaenge(\"US\")<\/pre>\nErgebnisse:<\/p>\n
22\r\n21\r\n0<\/pre>\nDer Rückgabewert 0 <\/b>bedeutet, dass das Land von der Funktion nicht unterstützt wird. Die IBAN wird in diesem Fall abgelehnt, weil ihre vorgeschriebene Länge nicht geprüft werden kann – sonst könnte eine formal passende Nummer mit einem gar nicht vergebenen Ländercode als gültig durchgehen.<\/p>\n
Die Liste deckt die für den deutschsprachigen Raum wichtigsten Länder ab. Insgesamt gibt es rund 80 IBAN-Länder; die vollständige und verbindliche Aufstellung pflegt die Organisation SWIFT im sogenannten IBAN-Register. Wenn Sie international arbeiten, ergänzen Sie die Liste entsprechend – oder lagern sie in eine Tabelle aus.<\/p>\n
Der umgekehrte Weg ist ebenso nützlich: aus Ländercode und der bereits zusammengesetzten nationalen Kontokennung, der BBAN, die vollständige IBAN erzeugen. Dazu setzt man wie in der Funktion IbanErzeugen <\/b>aus Listing 6 zunächst zwei Nullen als Platzhalter ein und zieht den ermittelten Rest von 98 ab:<\/p>\nPublic Function <\/span>IbanErzeugen(ByVal strLand As String<\/span>, ByVal strBban As String<\/span>) As String<\/span>\r\n Dim <\/span>strRoh As String<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n Dim <\/span>lngRest As Long<\/span>\r\n Dim <\/span>strPruefziffern As String<\/span>\r\n strLand = UCase(Bereinigt(strLand, \"^[A-Z]{2}$\"))\r\n If <\/span>Len<\/span>(strLand) <> 2 Then<\/span> Exit Function<\/span>\r\n lngLaenge = IbanLaenge(strLand)\r\n If <\/span>lngLaenge = 0 Then<\/span> Exit Function<\/span>\r\n strBban = Bereinigt(strBban, \"^[A-Z0-9 ]+$\")\r\n If <\/span>Len<\/span>(strBban) <> lngLaenge - 4 Then<\/span> Exit Function<\/span>\r\n If <\/span>strLand = \"DE\" Then<\/span>\r\n If <\/span>Not<\/span> RegExTest(strBban, \"^\\d{18}$\") Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strRoh = strLand & \"00\" & strBban\r\n lngRest = Modulo97(IbanInZiffern(strRoh))\r\n strPruefziffern = Format(98 - lngRest, \"00\")\r\n IbanErzeugen = strLand & strPruefziffern & strBban\r\nEnd Function<\/span><\/pre>\nListing 6: Erzeugen einer IBAN aus Ländercode und BBAN<\/span><\/b><\/p>\nDebug.Print<\/span> IbanErzeugen(\"DE\", _\r\n \"3704 0044 0532 0130 00\")\r\nDebug.Print<\/span> \"[\" & IbanErzeugen( _\r\n \"DE\", \"370400440532013\") & \"]\"<\/pre>\nErgebnisse:<\/p>\n
DE89370400440532013000\r\n[]<\/pre>\nDer zweite Aufruf liefert einen Leerstring, weil die übergebene BBAN nur 15 statt 18 Stellen hat.<\/p>\n
Beachten Sie, dass die Funktion keine Bankleitzahl und Kontonummer entgegennimmt, sondern die bereits korrekt zusammengesetzte BBAN. Wie diese aufgebaut ist, legt jedes Land selbst fest. In Deutschland besteht sie aus der achtstelligen Bankleitzahl und der Kontonummer, die dabei links mit führenden Nullen<\/b> auf zehn Stellen aufgefüllt werden muss.<\/p>\n
Für die Bankleitzahl 37040044 und die Kontonummer 532013000 ergibt das die BBAN 370400440532013000<\/b>, und der Aufruf IbanErzeugen(„DE“, „370400440532013000“)<\/b> liefert die IBAN DE89370400440532013000<\/b>.<\/p>\n
Die Funktion berechnet die IBAN-Prüfziffer, validiert aber nicht den landesspezifischen Aufbau der BBAN. Für Deutschland müsste zusätzlich geprüft werden, ob die BBAN ausschließlich aus 18 Ziffern besteht – genau das erledigt die Abfrage auf den Ländercode im Listing. Für andere Länder wären entsprechende Regeln zu ergänzen, denn manche BBAN-Formate enthalten tatsächlich Buchstaben.<\/p>\n
Rezept 2: ISBN-10<\/h2>\n
Bis Ende 2006 wurden ISBNs zehnstellig vergeben; seit 2007 werden ausschließlich dreizehnstellige ISBNs verwendet. Bei älteren Büchern begegnet Ihnen deshalb häufig noch die ISBN-10. Ihr Verfahren arbeitet mit dem Modulus 11 und gewichtet jede Stelle mit ihrer Position. Die Summe aller zehn gewichteten Ziffern muss glatt durch 11 teilbar sein.<\/p>\n
Weil ein Rest von 10 auftreten kann, dieser aber nicht in eine Ziffer passt, wird er als X<\/b> geschrieben. Das ist der Grund für die auf den ersten Blick verwunderlichen ISBN-Nummern, die mit einem Buchstaben enden.<\/p>\n
Die Funktion zum Prüfen einer ISBN namens IstIsbn10 <\/b>finden wir in Listing 7. Hier sind Beispiele zu dieser Funktion:<\/p>\nPublic Function <\/span>IstIsbn10(ByVal strIsbn As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strWert As String<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>lngZiffer As Long<\/span>\r\n Dim <\/span>lngSumme As Long<\/span>\r\n ' Ziffern, X sowie Bindestrich und Leerzeichen\r\n strWert = Bereinigt(strIsbn, \"^[0-9X \\-]+$\")\r\n If <\/span>Not<\/span> RegExTest(strWert, \"^\\d{9}[\\dX]$\") Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n For lngPos = 1 To 10\r\n If <\/span>Mid<\/span>(strWert, lngPos, 1) = \"X\" Then<\/span>\r\n lngZiffer = 10\r\n Else<\/span>\r\n lngZiffer = CLng(Mid<\/span>(strWert, lngPos, 1))\r\n End If<\/span>\r\n lngSumme = lngSumme + lngPos * lngZiffer\r\n Next<\/span> lngPos\r\n IstIsbn10 = (lngSumme Mod<\/span> 11 = 0)\r\nEnd Function<\/span><\/pre>\nListing 7: Prüfen einer zehnstelligen ISBN<\/span><\/b><\/p>\nDebug.Print<\/span> IstIsbn10(\"0-306-40615-2\")\r\nDebug.Print<\/span> IstIsbn10(\"0-8044-2957-X\")\r\nDebug.Print<\/span> IstIsbn10(\"0-306-40615-3\")<\/pre>\nErgebnisse:<\/p>\n
Wahr\r\nWahr\r\nFalsch<\/pre>\nDer zweite Aufruf zeigt eine ISBN mit dem X als Prüfziffer, der dritte dieselbe Nummer wie der erste mit einer verfälschten letzten Stelle.<\/p>\n
Das X darf ausschließlich an der letzten Stelle stehen, was das Muster im regulären Ausdruck bereits sicherstellt.<\/p>\n
Rezept 3: GTIN und ISBN-13<\/h2>\n
Die Identifikationsnummern GTIN-8, GTIN-12, GTIN-13 und GTIN-14 sowie die heutige ISBN-13 verwenden dasselbe Prüfziffernverfahren. GS1 bezeichnet die Varianten heute durchgängig als GTIN; die ältere Bezeichnung EAN begegnet Ihnen in älteren Datenbeständen aber weiterhin. Und noch eine Unterscheidung lohnt sich: Die GTIN ist die Nummer, der Strichcode lediglich ihr grafischer Datenträger.<\/p>\n
Bei diesem Verfahren werden die Stellen abwechselnd mit 1 und 3 gewichtet, und zwar so, dass die Stelle unmittelbar links von der Prüfziffer das Gewicht 3 erhält.<\/p>\n
Die Prüfziffer füllt die Summe dann auf das nächste Vielfache von 10 auf.<\/p>\n
Die Zählung von rechts ist entscheidend, weil die Nummern unterschiedlich lang sind. Wer stattdessen von links mit 1 beginnt, erhält bei der GTIN-8 ein falsches Ergebnis. Wir berechnen die Prüfziffer deshalb in einer eigenen Funktion namens GtinPruefziffer<\/b> (siehe Listing 8).<\/p>\nPublic Function <\/span>GtinPruefziffer(ByVal strNutzdaten As String<\/span>) As String<\/span>\r\n Dim <\/span>lngPos As Long<\/span>\r\n Dim <\/span>lngLaenge As Long<\/span>\r\n Dim <\/span>lngGewicht As Long<\/span>\r\n Dim <\/span>lngSumme As Long<\/span>\r\n lngLaenge = Len<\/span>(strNutzdaten)\r\n For lngPos = lngLaenge To 1 Step -1\r\n If <\/span>(lngLaenge - lngPos) Mod<\/span> 2 = 0 Then<\/span>\r\n lngGewicht = 3\r\n Else<\/span>\r\n lngGewicht = 1\r\n End If<\/span>\r\n lngSumme = lngSumme + lngGewicht _\r\n * CLng(Mid<\/span>(strNutzdaten, lngPos, 1))\r\n Next<\/span> lngPos\r\n GtinPruefziffer = CStr((10 - (lngSumme Mod<\/span> 10)) Mod<\/span> 10)\r\nEnd Function<\/span><\/pre>\nListing 8: Berechnen der Prüfziffer für eine GTIN<\/span><\/b><\/p>\n