Sukurkite atsitiktinius formatą atitinkančius IBAN numerius arba patikrinkite esamus su mūsų paprastu įrankiu. Puikiai tinka finansinių programų, bankininkystės programinės įrangos testavimui ir edukaciniais tikslais.
Tarptautinis banko sąskaitos numeris (IBAN) Generatorius ir Validatorius yra išsamus įrankis, sukurtas testavimo ir patikros tikslais finansinėse programose, bankinėje programinėje įrangoje ir švietimo kontekstuose. Ši vartotojui patogi programa siūlo dvi esmines funkcijas: atsitiktinių, tačiau formato atitinkančių IBAN generavimą ir vartotojo įvestų IBAN struktūrinio vientisumo patikrinimą. Nesvarbu, ar esate programuotojas, testuojantis finansinę programinę įrangą, QA specialistas, tikrinantis bankines programas, ar pedagogas, aiškinantis tarptautinius bankininkystės standartus, šis įrankis suteikia paprastą sprendimą, nereikalaujantį sudėtingų konfigūracijų ar trečiųjų šalių integracijų.
IBAN (Tarptautiniai banko sąskaitos numeriai) yra standartizuoti sąskaitų identifikatoriai, naudojami tarptautiniu mastu, siekiant palengvinti tarptautinius pervedimus ir sumažinti klaidas tarptautinėse pinigų perlaidose. Kiekvienas IBAN susideda iš šalies kodo, kontrolinių skaitmenų ir pagrindinio banko sąskaitos numerio (BBAN), kuris atitinka šalies specifinius formatus. Mūsų įrankis palaiko daugybę šalių formatų ir užtikrina, kad visi sugeneruoti IBAN atitiktų MOD 97 patikros algoritmą, nurodytą ISO 13616 standarte.
IBAN susideda iš iki 34 alfanumerinių simbolių, nors tikslus ilgis skiriasi priklausomai nuo šalies. Standartinė struktūra apima:
Pavyzdžiui, Vokietijos IBAN atitinka struktūrą DE2!n8!n10!n, kur:
DE yra šalies kodas2!n atstovauja du skaitmeninius kontrolinius skaitmenis8!n atstovauja aštuonių skaitmenų banko kodą10!n atstovauja dešimties skaitmenų sąskaitos numerįSkirtingos šalys turi skirtingus BBAN formatus, dėl to IBAN ilgiai skiriasi:
| Šalis | Ilgis | Struktūra | Pavyzdys |
|---|---|---|---|
| Vokietija (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| JK (GB) | 22 | GB2!n4!a6!n8!n | GB29NWBK60161331926819 |
| Prancūzija (FR) | 27 | FR2!n5!n5!n11!c2!n | FR1420041010050500013M02606 |
| Ispanija (ES) | 24 | ES2!n4!n4!n1!n1!n10!n | ES9121000418450200051332 |
| Italija (IT) | 27 | IT2!n1!a5!n5!n12!c | IT60X0542811101000000123456 |
IBAN patikros procesas naudoja MOD 97 algoritmą, kaip nurodyta ISO 7064 standarte. Štai kaip tai veikia:
Matematiškai tai pateikiama kaip:
Mūsų validatorius įgyvendina šį algoritmą, kad patikrintų bet kurio vartotojo įvesto IBAN struktūrinį vientisumą.
IBAN generatorius kuria atsitiktinius, tačiau galiojančius IBAN testavimo tikslais. Pagrindinės funkcijos apima:
Generatorius sukuria IBAN:
IBAN validatorius tikrina vartotojo įvestų IBAN struktūrinį vientisumą. Pagrindinės funkcijos apima:
Validatorius atlieka kelis patikrinimus:
IBAN Generatorius ir Validatorius įrankis tarnauja kelioms paskirtims skirtingose srityse:
Nors mūsų IBAN Generatorius ir Validatorius įrankis siūlo supaprastintą patirtį testavimo tikslais, yra alternatyvių požiūrių, kuriuos galima apsvarstyti:
Mūsų įrankis užpildo spragą tarp šių alternatyvų, teikdamas paprastą, prieinamą sąsają tiek generavimui, tiek validavimui, nereikalaujant techninės integracijos ar mokamų prenumeratų.
IBAN (Tarptautinis banko sąskaitos numeris) yra standartizuota tarptautinė numeravimo sistema, sukurta identifikuoti banko sąskaitas per nacionalines sienas. Ją sukūrė Tarptautinė standartizacijos organizacija (ISO), siekiant palengvinti be klaidų tarptautinius sandorius.
IBAN generatorius kuria struktūriškai galiojančius IBAN, kurie praeina MOD 97 patikros algoritmą, kaip nurodyta ISO 13616 standarte. Nors sugeneruoti IBAN yra matematiškai galiojantys, jie yra atsitiktiniai ir nesusiję su tikromis banko sąskaitomis, todėl puikiai tinka testavimui, bet ne realiems sandoriams.
Įrankis šiuo metu palaiko IBAN formatus Vokietijai, Jungtinei Karalystei, Prancūzijai, Ispanijai, Italijai, Nyderlandams, Šveicarijai, Austrijai, Belgijai ir Lenkijai. Šios šalys apima dažniausiai naudojamus IBAN formatus Europoje.
Ne. Šie generatoriaus sukurti IBAN yra struktūriškai galiojantys, tačiau atsitiktiniai. Jie nėra susiję su tikromis banko sąskaitomis ir turėtų būti naudojami tik testavimo, švietimo ar demonstravimo tikslais.
Validatorius patikrina kelis IBAN aspektus:
Ne. Nors IBAN dažnai rodomi su tarpais dėl skaitomumo (paprastai grupėmis po keturis simbolius), tarpai ignoruojami validavimo metu. Mūsų įrankis tvarko tiek suformatuotus, tiek neformatuotus IBAN.
Ne. Šis įrankis veikia visiškai jūsų naršyklėje. Jokie IBAN duomenys nėra siunčiami į jokį serverį, saugomi ar dalijami su trečiosiomis šalimis. Jūsų duomenys lieka privatūs ir saugūs.
Šiuo metu įrankis tik patikrina IBAN iš palaikomų šalių, išvardytų išskleidžiamajame sąraše. Jei jums reikia validacijos papildomoms šalims, prašome pranešti mums per atsiliepimų formą.
IBAN gali nepavykti validuoti dėl kelių priežasčių:
Mes laukiame atsiliepimų, kad patobulintume įrankį. Prašome naudoti atsiliepimų formą, kurią galite rasti per nuorodą puslapio apačioje, kad praneštumėte apie bet kokias problemas ar pasiūlytumėte patobulinimus.
Kūrėjams, kurie domisi IBAN validavimo ir generavimo įgyvendinimu savo programose, pateikiame kodo pavyzdžius įvairiomis programavimo kalbomis:
1function validateIban(iban) {
2 // Pašalinti tarpus ir konvertuoti į didžiąsias raides
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Patikrinti bazinį formatą
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Perkelti pirmus 4 simbolius į pabaigą
11 const rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
12 // Paversti raides į skaičius
13 const converted = rearranged.split('').map(char => {
14 if (/[A-Z]/.test(char)) {
15 return (char.charCodeAt(0) - 55).toString();
16 }
17 return char;
18 }).join('');
19
20 // Apskaičiuoti mod 97
21 let remainder = 0;
22 for (let i = 0; i < converted.length; i++) {
23 remainder = (remainder * 10 + parseInt(converted[i], 10)) % 97;
24 }
25
26 return remainder === 1;
27}
28
29// Pavyzdžio naudojimas
30console.log(validateIban('DE89 3704 0044 0532 0130 00')); // true
31console.log(validateIban('GB29 NWBK 6016 1331 9268 19')); // true
32console.log(validateIban('DE89 3704 0044 0532 0130 01')); // false (neteisingi kontroliniai skaitmenys)
331def validate_iban(iban):
2 # Pašalinti tarpus ir konvertuoti į didžiąsias raides
3 iban = iban.replace(' ', '').upper()
4
5 # Bazinio formato patikra
6 if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7 return False
8
9 # Perkelti pirmus 4 simbolius į pabaigą
10 rearranged = iban[4:] + iban[:4]
11
12 # Paversti raides į skaičius (A=10, B=11, ..., Z=35)
13 converted = ''
14 for char in rearranged:
15 if char.isalpha():
16 converted += str(ord(char) - 55)
17 else:
18 converted += char
19
20 # Patikrinti ar mod 97 lygus 1
21 return int(converted) % 97 == 1
22
23# Pavyzdžio naudojimas
24print(validate_iban('DE89 3704 0044 0532 0130 00')) # True
25print(validate_iban('GB29 NWBK 6016 1331 9268 19')) # True
26print(validate_iban('DE89 3704 0044 0532 0130 01')) # False (neteisingi kontroliniai skaitmenys)
271public class IbanValidator {
2 public static boolean validateIban(String iban) {
3 // Pašalinti tarpus ir konvertuoti į didžiąsias raides
4 String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5
6 // Bazinio formato patikra
7 if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8 return false;
9 }
10
11 // Perkelti pirmus 4 simbolius į pabaigą
12 String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13
14 // Paversti raides į skaičius
15 StringBuilder converted = new StringBuilder();
16 for (char c : rearranged.toCharArray()) {
17 if (Character.isLetter(c)) {
18 converted.append(c - 'A' + 10);
19 } else {
20 converted.append(c);
21 }
22 }
23
24 // Apskaičiuoti mod 97
25 BigInteger numeric = new BigInteger(converted.toString());
26 return numeric.mod(BigInteger.valueOf(97)).intValue() == 1;
27 }
28
29 public static void main(String[] args) {
30 System.out.println(validateIban("DE89 3704 0044 0532 0130 00")); // true
31 System.out.println(validateIban("GB29 NWBK 6016 1331 9268 19")); // true
32 System.out.println(validateIban("DE89 3704 0044 0532 0130 01")); // false
33 }
34}
351function generateIban(countryCode) {
2 const countryFormats = {
3 'DE': { length: 22, bbanPattern: '8n10n' },
4 'GB': { length: 22, bbanPattern: '4a6n8n' },
5 'FR': { length: 27, bbanPattern: '5n5n11c2n' }
6 // Pridėti daugiau šalių, jei reikia
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`Šalies kodas ${countryCode} nepalaikomas`);
11 }
12
13 // Generuoti atsitiktinį BBAN pagal šalies formatą
14 let bban = '';
15 const pattern = countryFormats[countryCode].bbanPattern;
16 let i = 0;
17
18 while (i < pattern.length) {
19 const count = parseInt(pattern.substring(i + 1), 10);
20 const type = pattern[i];
21
22 if (type === 'n') {
23 // Generuoti skaitmeninius simbolius
24 for (let j = 0; j < count; j++) {
25 bban += Math.floor(Math.random() * 10);
26 }
27 } else if (type === 'a') {
28 // Generuoti raidinius simbolius
29 for (let j = 0; j < count; j++) {
30 bban += String.fromCharCode(65 + Math.floor(Math.random() * 26));
31 }
32 } else if (type === 'c') {
33 // Generuoti alfanumerinius simbolius
34 for (let j = 0; j < count; j++) {
35 const isLetter = Math.random() > 0.5;
36 if (isLetter) {
37 bban += String.fromCharCode(65 + Math.floor(Math.random() * 26));
38 } else {
39 bban += Math.floor(Math.random() * 10);
40 }
41 }
42 }
43
44 i += 2;
45 }
46
47 // Apskaičiuoti kontrolinius skaitmenis
48 const checkDigits = calculateCheckDigits(countryCode, bban);
49
50 return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54 // Sukurti pradinį IBAN su '00' kaip kontroliniais skaitmenimis
55 const initialIban = countryCode + '00' + bban;
56
57 // Perkelti ir paversti raides į skaičius
58 const rearranged = bban + countryCode + '00';
59 const converted = rearranged.split('').map(char => {
60 if (/[A-Z]/.test(char)) {
61 return (char.charCodeAt(0) - 55).toString();
62 }
63 return char;
64 }).join('');
65
66 // Apskaičiuoti 98 minus mod 97
67 let remainder = 0;
68 for (let i = 0; i < converted.length; i++) {
69 remainder = (remainder * 10 + parseInt(converted[i], 10)) % 97;
70 }
71
72 const checkDigits = (98 - remainder).toString().padStart(2, '0');
73 return checkDigits;
74}
75
76// Pavyzdžio naudojimas
77console.log(generateIban('DE')); // Generuoja galiojantį Vokietijos IBAN
78console.log(generateIban('GB')); // Generuoja galiojantį JK IBAN
791import random
2import string
3
4def generate_iban(country_code):
5 country_formats = {
6 'DE': {'length': 22, 'bban_format': '8n10n'},
7 'GB': {'length': 22, 'bban_format': '4a6n8n'},
8 'FR': {'length': 27, 'bban_format': '5n5n11c2n'}
9 # Pridėti daugiau šalių, jei reikia
10 }
11
12 if country_code not in country_formats:
13 raise ValueError(f"Šalies kodas {country_code} nepalaikomas")
14
15 # Generuoti atsitiktinį BBAN pagal šalies formatą
16 bban = ''
17 format_str = country_formats[country_code]['bban_format']
18 i = 0
19
20 while i < len(format_str):
21 count = int(''.join(c for c in format_str[i+1:] if c.isdigit()))
22 type_char = format_str[i]
23
24 if type_char == 'n': # Skaitinis
25 bban += ''.join(random.choices(string.digits, k=count))
26 elif type_char == 'a': # Raidinis
27 bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28 elif type_char == 'c': # Alfanumerinis
29 bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30
31 i += 1 + len(str(count))
32
33 # Apskaičiuoti kontrolinius skaitmenis
34 check_digits = calculate_check_digits(country_code, bban)
35
36 return country_code + check_digits + bban
37
38def calculate_check_digits(country_code, bban):
39 # Sukurti eilutę kontrolinių skaitmenų skaičiavimui
40 check_string = bban + country_code + '00'
41
42 # Paversti raides į skaičius (A=10, B=11, ..., Z=35)
43 numeric = ''
44 for char in check_string:
45 if char.isalpha():
46 numeric += str(ord(char.upper()) - 55)
47 else:
48 numeric += char
49
50 # Apskaičiuoti 98 minus mod 97
51 remainder = int(numeric) % 97
52 check_digits = str(98 - remainder).zfill(2)
53
54 return check_digits
55
56# Pavyzdžio naudojimas
57print(generate_iban('DE')) # Generuoja galiojantį Vokietijos IBAN
58print(generate_iban('GB')) # Generuoja galiojantį JK IBAN
59IBAN Generatorius ir Validatorius įrankis siūlo paprastą, tačiau galingą sprendimą testavimo ir švietimo tikslais, susijusiems su tarptautiniais banko identifikatoriais. Siūlydamas tiek generavimo, tiek validavimo galimybes vartotojui patogioje sąsajoje, jis pašalina poreikį sudėtingoms konfigūracijoms ar trečiųjų šalių integracijoms.
Nesvarbu, ar kuriate finansines programas, testuojate mokėjimų sistemas, ar mokotės apie tarptautinius bankininkystės standartus, šis įrankis siūlo paprastą būdą dirbti su IBAN. Išsami validacija užtikrina, kad visi sugeneruoti IBAN būtų struktūriškai tinkami ir atitiktų tarptautinius standartus.
Išbandykite generuoti ar validuoti IBAN dabar, kad patirtumėte įrankio galimybes iš pirmų lūpų!
Raskite daugiau įrankių, kurie gali būti naudingi jūsų darbo eiga.