Izveidojiet nejaušus, formātam atbilstošus IBAN vai validējiet esošos ar mūsu vienkāršo rīku. Ideāli piemērots finanšu lietojumprogrammu, banku programmatūras un izglītības mērķiem.
Starptautiskā bankas konta numura (IBAN) ģenerators un validētājs ir visaptverošs rīks, kas paredzēts testēšanai un pārbaudei finanšu lietojumprogrammās, banku programmatūrā un izglītības kontekstos. Šī lietotājam draudzīgā lietojumprogramma piedāvā divas būtiskas funkcijas: ģenerēt nejaušus, taču formātam atbilstošus IBAN un validēt lietotāja ievadītos IBAN struktūras integritāti. Neatkarīgi no tā, vai esat izstrādātājs, kas testē finanšu programmatūru, kvalitātes nodrošināšanas speciālists, kas pārbauda banku lietojumprogrammas, vai izglītības speciālists, kas skaidro starptautiskos banku standartus, šis rīks piedāvā vienkāršu risinājumu, neprasot sarežģītu konfigurāciju vai trešo pušu integrācijas.
IBAN (Starptautiskie bankas konta numuri) ir standartizēti konta identifikatori, kas tiek izmantoti starptautiski, lai atvieglotu pārrobežu darījumus un samazinātu kļūdas starptautiskajās naudas pārskaitījumos. Katrs IBAN sastāv no valsts koda, pārbaudes cipariem un pamata bankas konta numura (BBAN), kas seko valsts specifiskajiem formātiem. Mūsu rīks atbalsta vairākus valstu formātus un nodrošina, ka visi ģenerētie IBAN iztur MOD 97 validācijas algoritmu, kas noteikts ISO 13616 standartā.
IBAN sastāv no līdz 34 alfanumeriskām zīmēm, lai gan precīzs garums atšķiras atkarībā no valsts. Standarta struktūra ietver:
Piemēram, Vācijas IBAN seko struktūrai DE2!n8!n10!n, kur:
DE ir valsts kods2!n attēlo divus ciparus8!n attēlo astoņu ciparu bankas kodu10!n attēlo desmit ciparu konta numuruAtšķirīgām valstīm ir dažādi BBAN formāti, kas rezultē dažādās IBAN garumos:
| Valsts | Garums | Struktūra | Piemērs |
|---|---|---|---|
| Vācija (DE) | 22 | DE2!n8!n10!n | DE89370400440532013000 |
| Apvienotā Karaliste (GB) | 22 | GB2!n4!a6!n8!n | GB29NWBK60161331926819 |
| Francija (FR) | 27 | FR2!n5!n5!n11!c2!n | FR1420041010050500013M02606 |
| Spānija (ES) | 24 | ES2!n4!n4!n1!n1!n10!n | ES9121000418450200051332 |
| Itālija (IT) | 27 | IT2!n1!a5!n5!n12!c | IT60X0542811101000000123456 |
IBAN validācijas process izmanto MOD 97 algoritmu, kā noteikts ISO 7064 standartā. Šeit ir tā darbības princips:
Matemātiski tas tiek attēlots šādi:
Mūsu validētājs īsteno šo algoritmu, lai pārbaudītu jebkura lietotāja ievadītā IBAN struktūras integritāti.
IBAN ģenerators rada nejaušus, taču derīgus IBAN testēšanas nolūkiem. Galvenās funkcijas ietver:
Ģenerators izveido IBAN, veicot:
IBAN validētājs pārbauda lietotāja ievadīto IBAN struktūras integritāti. Galvenās funkcijas ietver:
Validētājs veic vairākas pārbaudes:
IBAN ģeneratora un validētāja rīks kalpo vairākiem mērķiem dažādās jomās:
Lai gan mūsu IBAN ģeneratora un validētāja rīks piedāvā vienkāršu pieredzi testēšanas nolūkiem, ir arī citas pieejas, ko apsvērt:
Mūsu rīks aizpilda šo alternatīvu plaisu, piedāvājot vienkāršu, pieejamu saskarni gan ģenerēšanai, gan validācijai, neprasot tehnisku integrāciju vai maksājumus.
IBAN (Starptautiskais bankas konta numurs) ir standartizēta starptautiska numuru sistēma, ko izstrādājusi Starptautiskā standartizācijas organizācija (ISO), lai identificētu bankas kontus pāri valstu robežām. To izveidoja, lai atvieglotu kļūdu brīvus starptautiskos darījumus.
IBAN ģenerators rada strukturāli derīgus IBAN, kas iztur MOD 97 pārbaudes algoritmu, kā noteikts ISO 13616 standartā. Lai gan ģenerētie IBAN ir matemātiski derīgi, tie ir nejauši un nav saistīti ar reāliem bankas kontiem, padarot tos ideāliem testēšanai, bet ne reāliem darījumiem.
Rīks pašlaik atbalsta IBAN formātus Vācijai, Apvienotajai Karalistei, Francijai, Spānijai, Itālijai, Nīderlandei, Šveicei, Austrijai, Beļģijai un Polijai. Šīs aptver visbiežāk izmantotos IBAN formātus Eiropā.
Nē. Šī ģeneratora radītie IBAN ir strukturāli derīgi, bet nejauši ģenerēti. Tie nav savienoti ar reāliem bankas kontiem un jāizmanto tikai testēšanas, izglītības vai demonstrācijas nolūkiem.
Validētājs pārbauda vairākus aspektus IBAN:
Nē. Lai gan IBAN bieži tiek attēlots ar atstarpēm lasāmībai (parasti grupās pa četriem simboliem), atstarpes tiek ignorētas validācijas laikā. Mūsu rīks apstrādā gan formatētus, gan neformatētus IBAN.
Nē. Šis rīks darbojas pilnībā jūsu pārlūkprogrammā. Neviens IBAN datu netiek nosūtīts uz serveri, glabāts vai kopīgots ar trešajām pusēm. Jūsu dati paliek privāti un droši.
Pašreiz rīks validē tikai IBAN no atbalstītajām valstīm, kas norādītas nolaižamajā sarakstā. Ja jums nepieciešama validācija papildu valstīm, lūdzu, dariet mums to zināmu, izmantojot atsauksmju veidlapu.
IBAN var neizturēt validāciju vairāku iemeslu dēļ:
Mēs laipni gaidām atsauksmes, lai uzlabotu rīku. Lūdzu, izmantojiet atsauksmju veidlapu, kas pieejama caur saiti lapas apakšā, lai ziņotu par jebkurām problēmām vai ieteiktu uzlabojumus.
Izstrādātājiem, kas interesējas par IBAN validācijas un ģenerēšanas īstenošanu savās lietojumprogrammās, šeit ir koda piemēri dažādās programmēšanas valodās:
1function validateIban(iban) {
2 // Noņem atstarpes un pārvērš uz lielajiem burtiem
3 const cleanedIban = iban.replace(/\s/g, '').toUpperCase();
4
5 // Pārbauda pamata formātu
6 if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleanedIban)) {
7 return false;
8 }
9
10 // Pārvieto pirmos 4 simbolus uz beigām
11 const rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
12 const converted = rearranged.split('').map(char => {
13 if (/[A-Z]/.test(char)) {
14 return (char.charCodeAt(0) - 55).toString();
15 }
16 return char;
17 }).join('');
18
19 // Aprēķina mod 97
20 let remainder = 0;
21 for (let i = 0; i < converted.length; i++) {
22 remainder = (remainder * 10 + parseInt(converted[i], 10)) % 97;
23 }
24
25 return remainder === 1;
26}
27
28// Piemēra lietojums
29console.log(validateIban('DE89 3704 0044 0532 0130 00')); // true
30console.log(validateIban('GB29 NWBK 6016 1331 9268 19')); // true
31console.log(validateIban('DE89 3704 0044 0532 0130 01')); // false (nepareizi pārbaudes cipari)
321def validate_iban(iban):
2 # Noņem atstarpes un pārvērš uz lielajiem burtiem
3 iban = iban.replace(' ', '').upper()
4
5 # Pamata formāta pārbaude
6 if not (len(iban) > 4 and iban[:2].isalpha() and iban[2:4].isdigit()):
7 return False
8
9 # Pārvieto pirmos 4 simbolus uz beigām
10 rearranged = iban[4:] + iban[:4]
11
12 # Pārvērš burtus skaitļos (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 # Pārbauda, vai mod 97 ir vienāds ar 1
21 return int(converted) % 97 == 1
22
23# Piemēra lietojums
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 (nepareizi pārbaudes cipari)
271public class IbanValidator {
2 public static boolean validateIban(String iban) {
3 // Noņem atstarpes un pārvērš uz lielajiem burtiem
4 String cleanedIban = iban.replaceAll("\\s", "").toUpperCase();
5
6 // Pamata formāta pārbaude
7 if (!cleanedIban.matches("[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}")) {
8 return false;
9 }
10
11 // Pārvieto pirmos 4 simbolus uz beigām
12 String rearranged = cleanedIban.substring(4) + cleanedIban.substring(0, 4);
13
14 // Pārvērš burtus skaitļos
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 // Aprēķina 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 // Pievienojiet vairāk valstis pēc nepieciešamības
7 };
8
9 if (!countryFormats[countryCode]) {
10 throw new Error(`Valsts kods ${countryCode} nav atbalstīts`);
11 }
12
13 // Ģenerē nejaušu BBAN atbilstoši valsts formātam
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 // Ģenerē skaitliskās rakstzīmes
24 for (let j = 0; j < count; j++) {
25 bban += Math.floor(Math.random() * 10);
26 }
27 } else if (type === 'a') {
28 // Ģenerē alfabētiskās rakstzīmes
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 // Ģenerē alfanumeriskās rakstzīmes
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 // Aprēķina pārbaudes ciparus
48 const checkDigits = calculateCheckDigits(countryCode, bban);
49
50 return countryCode + checkDigits + bban;
51}
52
53function calculateCheckDigits(countryCode, bban) {
54 // Izveido sākotnējo IBAN ar '00' kā pārbaudes cipariem
55 const initialIban = countryCode + '00' + bban;
56
57 // Pārvieto un pārvērš burtus skaitļos
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 // Aprēķina 98 mīnus 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// Piemēra lietojums
77console.log(generateIban('DE')); // Ģenerē derīgu Vācijas IBAN
78console.log(generateIban('GB')); // Ģenerē derīgu Lielbritānijas 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 # Pievienojiet vairāk valstis pēc nepieciešamības
10 }
11
12 if country_code not in country_formats:
13 raise ValueError(f"Valsts kods {country_code} nav atbalstīts")
14
15 # Ģenerē nejaušu BBAN atbilstoši valsts formātam
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': # Skaitlisks
25 bban += ''.join(random.choices(string.digits, k=count))
26 elif type_char == 'a': # Alfabētisks
27 bban += ''.join(random.choices(string.ascii_uppercase, k=count))
28 elif type_char == 'c': # Alfanumerisks
29 bban += ''.join(random.choices(string.ascii_uppercase + string.digits, k=count))
30
31 i += 1 + len(str(count))
32
33 # Aprēķina pārbaudes ciparus
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 # Izveido virkni pārbaudes ciparu aprēķināšanai
40 check_string = bban + country_code + '00'
41
42 # Pārvērš burtus skaitļos (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 # Aprēķina 98 mīnus mod 97
51 remainder = int(numeric) % 97
52 check_digits = str(98 - remainder).zfill(2)
53
54 return check_digits
55
56# Piemēra lietojums
57print(generate_iban('DE')) # Ģenerē derīgu Vācijas IBAN
58print(generate_iban('GB')) # Ģenerē derīgu Lielbritānijas IBAN
59IBAN ģeneratora un validētāja rīks nodrošina vienkāršu, taču jaudīgu risinājumu testēšanas un izglītības nolūkiem, kas saistīti ar starptautiskajiem banku identifikatoriem. Piedāvājot gan ģenerēšanas, gan validācijas iespējas lietotājam draudzīgā saskarnē, tas novērš nepieciešamību pēc sarežģītām konfigurācijām vai trešo pušu integrācijām.
Neatkarīgi no tā, vai izstrādājat finanšu lietojumprogrammas, testējat maksājumu sistēmas vai mācāt par starptautiskajiem banku standartiem, šis rīks piedāvā vienkāršu veidu, kā strādāt ar IBAN. Visaptveroša validācija nodrošina, ka visi ģenerētie IBAN ir strukturāli pareizi un atbilst starptautiskajiem standartiem.
Mēģiniet ģenerēt vai validēt IBAN tagad, lai pieredzētu rīka iespējas pirmajā personā!
Atklājiet vairāk rīku, kas varētu būt noderīgi jūsu darbplūsmai