IBAN: Difference between revisions

Line 24:

<~~lang~~ 11l>F mod97(numberstring)

<syntaxhighlight lang="11l">F mod97(numberstring)

V segstart = 0

V step = 9

Line 62:

L(account) [‘GB82 WEST 1234 5698 7654 32’,

‘GB82 TEST 1234 5698 7654 32’]

print(‘#. validation is: #.’.format(account, valid_iban(account)))</~~lang~~>

print(‘#. validation is: #.’.format(account, valid_iban(account)))</syntaxhighlight>

Line 71:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>package Iban_Code is

<syntaxhighlight lang="ada">package Iban_Code is

function Is_Legal(Iban : String) return Boolean;

end Iban_Code;</~~lang~~><lang ~~Ada~~>with Ada.Characters.Handling; use Ada.Characters.Handling;

end Iban_Code;</syntaxhighlight><syntaxhighlight lang="ada">with Ada.Characters.Handling; use Ada.Characters.Handling;

with Ada.Containers.Hashed_Maps;

with Ada.Strings.Hash;

Line 160:

Nations.insert("TR", 26); Nations.insert("AE", 23);

Nations.insert("GB", 22); Nations.insert("VG", 24);

end Iban_Code;</~~lang~~>Testing:

end Iban_Code;</syntaxhighlight>Testing:

<~~lang~~ ~~Ada~~>with Ada.Text_Io; use Ada.Text_Io;

<syntaxhighlight lang="ada">with Ada.Text_Io; use Ada.Text_Io;

with Iban_Code;

Line 181:

Check("GB82 TEST 1234 5698 7654 32");

Check("GB82 WEST 1243 5698 7654 32");

end Check_Iban;</~~lang~~>{{out}}

end Check_Iban;</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 is valid.

GB82WEST12345698765432 is valid.

Line 190:

=={{header|AppleScript}}==

<~~lang~~ applescript>on countryCodes()

<syntaxhighlight lang="applescript">on countryCodes()

-- A list of 34 lists. The nth list (1-indexed) contains country codes for countries having n-character IBANS.

return {{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {"NO"}, {"BE"}, ¬

Line 251:

set output to output as text

set AppleScript's text item delimiters to astid

return output</~~lang~~>

return output</syntaxhighlight>

<~~lang~~ applescript>"GB82 WEST 1234 5698 7654 32: valid

<syntaxhighlight lang="applescript">"GB82 WEST 1234 5698 7654 32: valid

gb82 west 1234 5698 7654 32: valid

GB82 TEST 1234 5698 7654 32: invalid

SA03 8000 0000 6080 1016 7519: valid

ZZ12 3456 7890 1234 5678 12: invalid

IL62 0108 0000 0009 9999 999: valid"</~~lang~~>

IL62 0108 0000 0009 9999 999: valid"</syntaxhighlight>

=={{header|Arturo}}==

<~~lang~~ rebol>ibanSize: #[

<syntaxhighlight lang="rebol">ibanSize: #[

AL: 28, AD: 24, AT: 20, AZ: 28, BE: 16

BH: 22, BA: 20, BR: 29, BG: 22, CR: 21, HR: 21, CY: 28

Line 293:

loop ["GB82 WEST 1234 5698 7654 32"

"GB82 TEST 1234 5698 7654 32"] 'ib

-> print [ib "=> valid?" valid? ib]</~~lang~~>

-> print [ib "=> valid?" valid? ib]</syntaxhighlight>

Line 302:

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>IBANs := ["GB82 WEST 1234 5698 7654 32"

<syntaxhighlight lang="autohotkey">IBANs := ["GB82 WEST 1234 5698 7654 32"

, "gb82 WEST 1234 5698 7654 32"

, "GB82WEST12345698765432"

Line 344:

}

return rem

}</~~lang~~>{{Out}}

}</syntaxhighlight>{{Out}}

GB82 WEST 1234 5698 7654 32 is valid.

gb82 WEST 1234 5698 7654 32 is valid.

Line 357:

This requires a gawk with extensions and GNU MP+MPFR support - it's usually the case. Some country codes are missing, the output is itself parsable.

<~~lang~~ awk>

@load "ordchr"

Line 407:

ibancsum % 97 == 1 ? valid() : invalid()

}</~~lang~~>

}</syntaxhighlight>

Creating a test file and launching the script:

<lang>

cat > test.iban

FR33 ^__^ 0BAD

Line 419:

^D

gawk -Mf iban.gawk test.iban

</syntaxhighlight>

</lang>

Output:

<lang>

INVALID FR33 ^__^ 0BAD

INVALID AA11 1234 6543 1212

Line 430:

VALID__ GB82 WEST 1234 5698 7654 32

INVALID GB82 TEST 1234 5698 7654 32

</syntaxhighlight>

</lang>

=={{header|BBC BASIC}}==

<~~lang~~ bbcbasic> REM Used the following as official standard:

<syntaxhighlight lang="bbcbasic"> REM Used the following as official standard:

REM http://www.cnb.cz/cs/platebni_styk/iban/download/EBS204.pdf

Line 526:

num$=MID$(num$,8)

ENDWHILE

=VALmod$</~~lang~~>{{out}}

=VALmod$</syntaxhighlight>{{out}}

valid IBAN: GB82 WEST 1234 5698 7654 32

valid IBAN: GB82WEST12345698765432

Line 542:

=={{header|Befunge}}==

<~~lang~~ befunge>>>" :NABI">:#,_>:~:"`"`48**-:55+-#v_$0::6g0>>8g-!\7g18g-!*!v>v>>

<<_#v:#78#`8#+<^+!!*-*84\-9:g8:p8\<oo>1#$-#<0$>>>#v_"dilav" ^#<<

>>^ >*-:20p9`9*1+55+**20g+"a"%10g1+00g%:4-!|^g6::_v#-*88:+1_vv>>

Line 549:

"-(&(/$$*$(*.-*.('$)*%0-&**.$'(.'/.+,''&&*.)**&,-.&.(*(*-!(%01-)

BFBBBBFFTNRRGGCCGCGGSSKSKSSDDHDHCPLPTLLLLPPAAVEIIAAAIEMMMNGMMMMI

ERGAHRIONLSOTRZYBRLIKIWMZAEOKREUHSBTRIVTUKLEDGESTLTZESEDCOEKUTRL</~~lang~~>

ERGAHRIONLSOTRZYBRLIKIWMZAEOKREUHSBTRIVTUKLEDGESTLTZESEDCOEKUTRL</syntaxhighlight>

Line 560:

=={{header|Bracmat}}==

<~~lang~~ bracmat>( ( IBAN-check

<syntaxhighlight lang="bracmat">( ( IBAN-check

= table country cd len N c

. (AL.28) (AD.24) (AT.20) (AZ.28) (BE.16) (BH.22) (BA.20) (BR.29)

Line 610:

& IBAN-check$"GB82 WEST 1243 5698 7654 32"

& IBAN-check$"GB82 west 1243 5698 7654 32"

);</~~lang~~>{{out}}

);</syntaxhighlight>{{out}}

wrong length

invalid country code: 'GX'

Line 621:

=={{header|C}}==

<~~lang~~ C>#include <alloca.h>

<syntaxhighlight lang="c">#include <alloca.h>

#include <ctype.h>

#include <stdio.h>

Line 717:

return 0;

}</~~lang~~>{{out}}

}</syntaxhighlight>{{out}}

iban 'GB82 WEST 1234 5698 7654 32' GB82TEST12345698765432

GB82WEST12345698765432 is valid.

Line 723:

=={{header|C sharp}}==

<~~lang~~ csharp> public class IbanValidator : IValidateTypes

<syntaxhighlight lang="csharp"> public class IbanValidator : IValidateTypes

{

public ValidationResult Validate(string value)

Line 841:

{"VG", 24}

};

}</~~lang~~>Demonstrating:

}</syntaxhighlight>Demonstrating:

<~~lang~~ csharp> public class When_the_IbanValidator_is_told_to_Validate

<syntaxhighlight lang="csharp"> public class When_the_IbanValidator_is_told_to_Validate

{

[Fact]

Line 941:

Assert.Equal(ValidationResult.IsValid, result);

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|C++}}==

<~~lang~~ cpp>#include <string>

<syntaxhighlight lang="cpp">#include <string>

#include <iostream>

#include <boost/algorithm/string.hpp>

Line 1,018:

SayValidity("GB82TEST12345698765432");

return 0;

}</~~lang~~>{{out}}

}</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 is valid!

GB82TEST12345698765432 is not valid!

Line 1,024:

=={{header|Caché ObjectScript}}==

<~~lang~~ cos>Class Utils.Validate [ Abstract ]

<syntaxhighlight lang="cos">Class Utils.Validate [ Abstract ]

{

Line 1,121:

}

}</~~lang~~>{{out|Examples}}

}</syntaxhighlight>{{out|Examples}}

<pre>USER>For { Read iban Quit:iban="" Write " => ", ##class(Utils.Validate).VerifyIBAN(iban), ! }

GB82 WEST 1234 5698 7654 32 => 1

Line 1,134:

=={{header|Clojure}}==

<~~lang~~ ~~Clojure~~>(def explen

<syntaxhighlight lang="clojure">(def explen

{"AL" 28 "AD" 24 "AT" 20 "AZ" 28 "BE" 16 "BH" 22 "BA" 20 "BR" 29

"BG" 22 "CR" 21 "HR" 21 "CY" 28 "CZ" 24 "DK" 18 "DO" 28 "EE" 20

Line 1,157:

(prn (valid-iban? "GB82 WEST 1234 5698 7654 32") ; true

(valid-iban? "GB82 TEST 1234 5698 7654 32")) ; false</~~lang~~>

(valid-iban? "GB82 TEST 1234 5698 7654 32")) ; false</syntaxhighlight>

=={{header|COBOL}}==

<~~lang~~ cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. iban-main.

Line 1,321:

END PROGRAM create-iban-number.

END PROGRAM validate-iban.</~~lang~~>{{out}}

END PROGRAM validate-iban.</syntaxhighlight>{{out}}

<pre>

GB82 WEST 1234 5698 7654 32 is valid.

Line 1,328:

=={{header|Common Lisp}}==

<~~lang~~ lisp>

;;

;; List of the IBAN code lengths per country.

Line 1,390:

(= 1 (mod (IBAN-to-integer X) 97)))))

(validp (remove #\Space iban))))

</syntaxhighlight>

</lang>

'''Output:'''

<pre>

Line 1,403:

=={{header|D}}==

<~~lang~~ d>import std.stdio, std.string, std.regex, std.conv, std.bigint,

<syntaxhighlight lang="d">import std.stdio, std.string, std.regex, std.conv, std.bigint,

std.algorithm, std.ascii;

Line 1,439:

"GB82 TEST 1234 5698 7654 32"])

writefln("%s validation is: %s", account, account.validIBAN);

}</~~lang~~>{{out}}

}</syntaxhighlight>{{out}}

<pre>GB82 WEST 1234 5698 7654 32 validation is: true

GB82 TEST 1234 5698 7654 32 validation is: false</pre>

=={{header|DBL}}==

<syntaxhighlight lang="dbl">;

<lang DBL>;

; Validate IBAN for DBL version 4 by Dario B.

;

Line 1,599:

ELSE ISVALID=

XRETURN

END</~~lang~~>

END</syntaxhighlight>

<pre>GB82 WEST 1234 5698 7654 32 is valid

Line 1,613:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule IBAN do

<syntaxhighlight lang="elixir">defmodule IBAN do

@len %{ AL: 28, AD: 24, AT: 20, AZ: 28, BE: 16, BH: 22, BA: 20, BR: 29,

BG: 22, CR: 21, HR: 21, CY: 28, CZ: 24, DK: 18, DO: 28, EE: 20,

Line 1,648:

"GB82 TEST 1234 5698 7654 32",

"ZZ12 3456 7890 1234 5678 12" ]

|> Enum.each(fn iban -> IO.puts "#{IBAN.valid?(iban)}\t#{iban}" end)</~~lang~~>

|> Enum.each(fn iban -> IO.puts "#{IBAN.valid?(iban)}\t#{iban}" end)</syntaxhighlight>

Line 1,661:

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>open System

<syntaxhighlight lang="fsharp">open System

open System.Text.RegularExpressions

Line 1,712:

|> function | Some(_) -> "a valid IBAN" | None -> "an invalid IBAN"

|> printfn "%s is %s" iban

0</~~lang~~>{{out}}

0</syntaxhighlight>{{out}}

>Rosetta.exe "GB82 WEST 1234 5698 7654 32"

GB82 WEST 1234 5698 7654 32 is a valid IBAN

Line 1,720:

=={{header|Factor}}==

<~~lang~~ factor>USING: assocs combinators.short-circuit formatting kernel math

<syntaxhighlight lang="factor">USING: assocs combinators.short-circuit formatting kernel math

math.parser regexp sequences sets qw unicode ;

IN: rosetta-code.iban

Line 1,769:

] bi@ ;

MAIN: iban-demo</~~lang~~>

MAIN: iban-demo</syntaxhighlight>

<pre>

Line 1,778:

=={{header|Forth}}==

<lang>include lib/ulcase.4th \ for S>UPPER

<syntaxhighlight lang="text">include lib/ulcase.4th \ for S>UPPER

include lib/triple.4th \ for UT/MOD

include lib/cstring.4th \ for C/STRING

Line 1,815:

;

checkiban</~~lang~~>

checkiban</syntaxhighlight>

<pre>linux:~> pp4th -x chkiban.4th

Line 1,825:

=={{header|Fortran}}==

<~~lang~~ fortran>

program ibancheck

Line 1,950:

end program ibancheck

</syntaxhighlight>

</lang>

Line 1,969:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>' FB 1.05.0 Win64

<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

' List updated to release 72, 25 November 2016, of IBAN Registry (75 countries)

Line 2,040:

Print

Print "Press any key to quit"

Sleep</~~lang~~>

Sleep</syntaxhighlight>

Line 2,050:

=={{header|Free Pascal}}==

<~~lang~~ ~~Delphi~~>{$mode objFPC}

<syntaxhighlight lang="delphi">{$mode objFPC}

uses

Line 2,130:

// note, strings longer than 34 characters will be silently clipped

writeLn(isLegal(delSpace('GB82 WEST 1234 5698 7654 32')));

end.</~~lang~~>

end.</syntaxhighlight>

Line 2,136:

=={{header|Go}}==

<~~lang~~ Go>package main

<syntaxhighlight lang="go">package main

import (

Line 2,205:

}

</syntaxhighlight>

</lang>

=={{header|Groovy}}==

<~~lang~~ groovy>def validateIBAN(String iban) {

<syntaxhighlight lang="groovy">def validateIBAN(String iban) {

def iso = [AL: 28, AD: 24, AT: 20, AZ: 28, BE: 16, BH: 22, BA: 20, BR: 29, BG: 22,

HR: 21, CY: 28, CZ: 24, DK: 18, DO: 28, EE: 20, FO: 18, FI: 18, FR: 27, GE: 22, DE: 22, GI: 23,

Line 2,223:

def number = iban.collect { Character.digit(it as char, 36) }.join('')

(number as BigInteger).mod(97) == 1

}</~~lang~~>

}</syntaxhighlight>

Testing:

<~~lang~~ groovy>[ 'GB82 WEST 1234 5698 7654 32',

<syntaxhighlight lang="groovy">[ 'GB82 WEST 1234 5698 7654 32',

'GB82 TEST 1234 5698 7654 32',

'GB81 WEST 1234 5698 7654 32',

Line 2,232:

'CH93 0076 2011 6238 5295 7' ].each { iban ->

println "$iban is ${validateIBAN(iban) ? 'valid' : 'invalid'}"

}</~~lang~~>

}</syntaxhighlight>

<pre>GB82 WEST 1234 5698 7654 32 is valid

Line 2,242:

=={{header|Haskell}}==

This program uses the Maybe and Either monads to handle failures. Values of type 'Maybe a' can contain 'Nothing' (no value) or 'Just a' (a value of type 'a'). Values of type 'Either a b' contain 'Left b' (usually indicating failure) or 'Right c' (usually indicating success).

<~~lang~~ ~~Haskell~~>import Data.Char (toUpper)

<syntaxhighlight lang="haskell">import Data.Char (toUpper)

import Data.Maybe (fromJust)

Line 2,294:

invalidBecause reason = Left $ "Invalid IBAN number " ++ xs ++

": " ++ reason</~~lang~~>{{out}}

": " ++ reason</syntaxhighlight>{{out}}

<pre>

validateIBAN "GB82 WEST 1234 5698 7654 32"

Line 2,316:

=={{header|IS-BASIC}}==

<~~lang~~ IS-~~BASIC~~>100 PROGRAM "IBAN.bas"

<syntaxhighlight lang="is-basic">100 PROGRAM "IBAN.bas"

110 STRING CO$(1 TO 93)*2

120 NUMERIC LG(1 TO 93)

Line 2,373:

650 DATA AD,24,AE,23,AL,28,AO,25,AT,20,AZ,28,BA,20,BE,16,BF,28,BG,22,BH,22,BI,16,BJ,28,BR,29,BY,28,CG,27,CH,21,CI,28,CM,27,CR,22,CV,25,CY,28,CZ,24,DE,22,DK,18,DO,28,DZ,24,EE,20,EG,27,ES,24,FI,18,FO,18,FR,27,GA,27,GB,22,GE,22,GI,23,GL,18

660 DATA GR,27,GT,28,HN,28,HR,21,HU,28,IE,22,IL,23,IR,26,IS,26,IT,27,JO,30,KM,27,KW,30,KZ,20,LB,28,LI,21,LT,20,LU,20,LV,21,MA,28,MC,27,MD,24,ME,22,MG,27,MK,19,ML,28,MR,27,MT,31,MU,30,MZ,25,NE,28,NI,32,NL,18,NO,15,PK,24,PL,28,PS,29,PT,25

670 DATA QA,29,RO,24,RS,22,SA,24,SE,24,SI,19,SK,24,SM,27,SN,28,TD,27,TG,28,TL,23,TN,24,TR,26,UA,29,VG,24,XK,20</~~lang~~>

670 DATA QA,29,RO,24,RS,22,SA,24,SE,24,SI,19,SK,24,SM,27,SN,28,TD,27,TG,28,TL,23,TN,24,TR,26,UA,29,VG,24,XK,20</syntaxhighlight>

=={{header|J}}==

<~~lang~~ J>NB. delete any blank characters

<syntaxhighlight lang="j">NB. delete any blank characters

delblk =. #~ ' '&~:

NB. rearrange

Line 2,410:

NB. IBAN

iban =: quads @: ibancheck

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

iban 'GB82 WEST 1234 5698 7654 32'

Line 2,425:

=={{header|Java}}==

<~~lang~~ java>import java.math.BigInteger;

<syntaxhighlight lang="java">import java.math.BigInteger;

import java.util.*;

Line 2,475:

return bigInt.mod(BigInteger.valueOf(97)).intValue() == 1;

}

}</~~lang~~>{{out}}

}</syntaxhighlight>{{out}}

<pre>GB82 WEST 1234 5698 7654 32 is valid.

GB82 TEST 1234 5698 7654 32 is not valid.

Line 2,487:

=={{header|JavaScript}}==

<~~lang~~ ~~JavaScript~~>var ibanLen = {

<syntaxhighlight lang="javascript">var ibanLen = {

NO:15, BE:16, DK:18, FI:18, FO:18, GL:18, NL:18, MK:19,

SI:19, AT:20, BA:20, EE:20, KZ:20, LT:20, LU:20, CR:21,

Line 2,514:

document.write(isValid('GB82 TEST 1234 5698 7654 32'), ' ') // false

document.write(isValid('SA03 8000 0000 6080 1016 7519'), ' ') // true

</syntaxhighlight>

</lang>

true

Line 2,525:

This implementation requires a version of jq with <tt>gsub</tt>.

The heart of the matter consists of just four lines of straightforward jq code:<~~lang~~ jq>

The heart of the matter consists of just four lines of straightforward jq code:<syntaxhighlight lang="jq">

# strip the input string of spaces and tabs:

gsub("[ \t]";"")

Line 2,534:

# check the mod 97 criterion:

and ( (.[4:] + .[0:4]) | letters2digits | remainder) == 1

</syntaxhighlight>

</lang>

This conciseness is achieved courtesy of the helper functions: <tt>letters2digits</tt> and <tt>remainder</tt>. These could be implemented as inner functions of the main function,

but for clarity they are shown as top-level functions here.

<~~lang~~ jq>def letters2digits:

<syntaxhighlight lang="jq">def letters2digits:

65 as $A | 90 as $Z

| ($A - 10) as $ten

Line 2,574:

and length == $lengths[.[0:2]]

# Shift and convert:

and ( (.[4:] + .[0:4]) | letters2digits | remainder) == 1 ;</~~lang~~>Examples<lang jq>

and ( (.[4:] + .[0:4]) | letters2digits | remainder) == 1 ;</syntaxhighlight>Examples<syntaxhighlight lang="jq">

"GB82 WEST 1234 5698 7654 32" | is_valid_iban #=> true

"GB82 TEST 1234 5698 7654 32" | is_valid_iban #=> false</~~lang~~>

"GB82 TEST 1234 5698 7654 32" | is_valid_iban #=> false</syntaxhighlight>

=={{header|Jsish}}==

From the Javascript entry.

<~~lang~~ javascript>var ibanLen = {

<syntaxhighlight lang="javascript">var ibanLen = {

NO:15, BE:16, DK:18, FI:18, FO:18, GL:18, NL:18, MK:19,

SI:19, AT:20, BA:20, EE:20, KZ:20, LT:20, LU:20, CR:21,

Line 2,617:

isIBAN('SA03 8000 0000 6080 1016 7519') ==> true

=!EXPECTEND!=

*/</~~lang~~>

*/</syntaxhighlight>

Line 2,626:

<~~lang~~ julia>function validiban(iban::AbstractString)

<syntaxhighlight lang="julia">function validiban(iban::AbstractString)

country2length = Dict(

"AL" => 28, "AD" => 24, "AT" => 20, "AZ" => 28, "BE" => 16, "BH" => 22, "BA" => 20, "BR" => 29,

Line 2,647:

digs = parse(BigInt, join(parse(Int, ch, 36) for ch in iban))

return rst && digs % 97 == 1

end</~~lang~~>

end</syntaxhighlight>

Line 2,654:

=={{header|Kotlin}}==

<~~lang~~ scala>// version 1.0.6

<syntaxhighlight lang="scala">// version 1.0.6

import java.math.BigInteger

Line 2,697:

println(iban + if (valid) " may be valid" else " is not valid")

}

}</~~lang~~>

}</syntaxhighlight>

Line 2,706:

=={{header|Lobster}}==

let cc = ["AD","AE","AL","AO","AT","AZ","BA","BE","BF","BG","BH","BI","BJ","BR","CG","CH","CI","CM","CR","CV","CY",

"CZ","DE","DK","DO","DZ","EE","EG","ES","FI","FO","FR","GA","GB","GE","GI","GL","GR","GT","HR","HU","IE",

Line 2,766:

assert not isValidIBAN("GB82 TEST 1234 5698 7654 32")

assert not isValidIBAN("GB82 WEST 1243 5698 7654 32")

</syntaxhighlight>

</lang>

=={{header|Logtalk}}==

<~~lang~~ logtalk>

:- object(iban).

Line 2,899:

:- end_object.

</syntaxhighlight>

</lang>

Testing:

<~~lang~~ logtalk>

| ?- iban::valid("GB82 WEST 1234 5698 7654 32").

yes

</syntaxhighlight>

</lang>

=={{header|Lua}}==

<~~lang~~ lua>local length=

<syntaxhighlight lang="lua">local length=

{

AL=28, AD=24, AT=20, AZ=28, BH=22, BE=16, BA=20, BR=29, BG=22, CR=21,

Line 2,930:

end

return mod==1

end</~~lang~~>

end</syntaxhighlight>

=={{header|M2000 Interpreter}}==

We make a lambda function which return a string, with the input IBAN plus (Valid) or (Invalid) at the end.

\\ IBAN checker

Function MakeIBANfun$ {

Line 2,977:

Print IbanCheck$("GR16 0110 1250 0000 0001 2300 695X")

Print IbanCheck$("MK11 2222 3333 4444 555")

</syntaxhighlight>

</lang>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>CountryCodes={{"AL",28},{"AD",24},{"AT",20},{"AZ",28},{"BE",16},{"BH",22},{"BA",20},{"BR",29},{"BG",22},{"CR",21},{"HR",21},{"CY",28},{"CZ",24},{"DK",18},{"DO",28},{"EE",20},{"FO",18},{"FI",18},{"FR",27},{"GE",22},{"DE",22},{"GI",23},{"GR",27},{"GL",18},{"GT",28},{"HU",28},{"IS",26},{"IE",22},{"IL",23},{"IT",27},{"KZ",20},{"KW",30},{"LV",21},{"LB",28},{"LI",21},{"LT",20},{"LU",20},{"MK",19},{"MT",31},{"MR",27},{"MU",30},{"MC",27},{"MD",24},{"ME",22},{"NL",18},{"NO",15},{"PK",24},{"PS",29},{"PL",28},{"PT",25},{"RO",24},{"SM",27},{"SA",24},{"RS",22},{"SK",24},{"SI",19},{"ES",24},{"SE",24},{"CH",21},{"TN",24},{"TR",26},{"AE",23},{"GB",22},{"VG",24}};

<syntaxhighlight lang="mathematica">CountryCodes={{"AL",28},{"AD",24},{"AT",20},{"AZ",28},{"BE",16},{"BH",22},{"BA",20},{"BR",29},{"BG",22},{"CR",21},{"HR",21},{"CY",28},{"CZ",24},{"DK",18},{"DO",28},{"EE",20},{"FO",18},{"FI",18},{"FR",27},{"GE",22},{"DE",22},{"GI",23},{"GR",27},{"GL",18},{"GT",28},{"HU",28},{"IS",26},{"IE",22},{"IL",23},{"IT",27},{"KZ",20},{"KW",30},{"LV",21},{"LB",28},{"LI",21},{"LT",20},{"LU",20},{"MK",19},{"MT",31},{"MR",27},{"MU",30},{"MC",27},{"MD",24},{"ME",22},{"NL",18},{"NO",15},{"PK",24},{"PS",29},{"PL",28},{"PT",25},{"RO",24},{"SM",27},{"SA",24},{"RS",22},{"SK",24},{"SI",19},{"ES",24},{"SE",24},{"CH",21},{"TN",24},{"TR",26},{"AE",23},{"GB",22},{"VG",24}};

ClearAll[IBANVerify]

IBANVerify[input_String]:=Module[{i,cc,rules},

Line 3,008:

False

]

]</~~lang~~>

]</syntaxhighlight>

Trying out the function:

<~~lang~~ ~~Mathematica~~>IBANVerify["GB82 WEST 1234 5698 7654 32"]

<syntaxhighlight lang="mathematica">IBANVerify["GB82 WEST 1234 5698 7654 32"]

IBANVerify["GB82 WEST 1234 5698 7654 323"]

IBANVerify["GB82 WEST 1234 5698 7654 31"]

IBANVerify["XX82 WEST 1234 5698 7654 323"]</~~lang~~>{{out}}

IBANVerify["XX82 WEST 1234 5698 7654 323"]</syntaxhighlight>{{out}}

True

False

Line 3,021:

=={{header|MATLAB}}==

Didn't check country codes, lengths, or consistent checksums to keep this applicable to any new countries.

<~~lang~~ ~~MATLAB~~>function valid = validateIBAN(iban)

<syntaxhighlight lang="matlab">function valid = validateIBAN(iban)

% Determine if International Bank Account Number is valid IAW ISO 13616

% iban - string containing account number

Line 3,050:

i2 = min(i1+8, nDig);

end

end</~~lang~~>Usage:

end</syntaxhighlight>Usage:

<~~lang~~ ~~MATLAB~~>tests = {'GB82 WEST 1234 5698 7654 32' ;

<syntaxhighlight lang="matlab">tests = {'GB82 WEST 1234 5698 7654 32' ;

'GB82 TEST 1234 5698 7654 32' ;

'CH93 0076 2011 6238 5295 7' ;

Line 3,061:

for k = 1:length(tests)

fprintf('%s -> %svalid\n', tests{k}, char(~validateIBAN(tests{k}).*'in'))

end</~~lang~~>{{out}}

end</syntaxhighlight>{{out}}

<pre>GB82 WEST 1234 5698 7654 32 -> valid

GB82 TEST 1234 5698 7654 32 -> invalid

Line 3,072:

=={{header|NewLISP}}==

(setq *iban-code-length* '((15 ("NO"))

(16 ("BE"))

Line 3,140:

)

</syntaxhighlight>

</lang>

Output:

<pre>

Line 3,152:

=={{header|Nim}}==

<~~lang~~ nim>import tables, strutils, re, bigints

<syntaxhighlight lang="nim">import tables, strutils, re, bigints

let countryLen = toTable({

Line 3,185:

for account in ["GB82 WEST 1234 5698 7654 32", "GB82 TEST 1234 5698 7654 32"]:

echo account, " validation is: ", validIban account</~~lang~~>{{out}}

echo account, " validation is: ", validIban account</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 validation is: true

GB82 TEST 1234 5698 7654 32 validation is: false

Line 3,191:

=={{header|Oberon-2}}==

Works with oo2c Version 2

<~~lang~~ oberon2>

MODULE IBAN;

IMPORT

Line 3,353:

Test;

END IBAN.

</syntaxhighlight>

</lang>

Output:

<pre>

Line 3,364:

=={{header|OCaml}}==

<~~lang~~ ocaml>

#load "str.cma"

#load "nums.cma" (* for module Big_int *)

Line 3,471:

in

List.iter (fun pair -> testit pair) ibans

</syntaxhighlight>

</lang>

GB82 WEST 1234 5698 7654 32 is valid. Expected true [PASS]

Line 3,482:

=={{header|Perl}}==

<~~lang~~ ~~Perl~~>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict ;

use warnings ;

Line 3,529:

if ( validate_iban( "GB82TEST12345698765432" ) ) {

print "GB82TEST12345698765432 is valid!\n" ;

}</~~lang~~>{{out}}

}</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 is a valid IBAN number!

GB82TEST12345698765432 is invalid!

=={{header|Phix}}==

--

-- demo\rosetta\IBAN.exw

Line 3,594:

test("SA03 8000 0000 6080 1016 7519",true)

test("CH93 0076 2011 6238 5295 7",true)

<pre>

Line 3,605:

=={{header|PHP}}==

<~~lang~~ php>

<?php

Line 3,685:

echo "IBAN NOT VALID";

}

</syntaxhighlight>

</lang>

=={{header|Picat}}==

<~~lang~~ ~~Picat~~>go =>

IBAN = "GB82 WEST 1234 5698 7654 32",

println(IBAN=iban(IBAN)),

Line 3,721:

"MR"=27, "MU"=30, "MC"=27, "MD"=24, "ME"=22, "NL"=18, "NO"=15, "PK"=24, "PS"=29, "PL"=28,

"PT"=25, "QA"=29, "RO"=24, "SM"=27, "SA"=24, "RS"=22, "SK"=24, "SI"=19, "ES"=24, "SE"=24,

"CH"=21, "TN"=24, "TR"=26, "AE"=23, "GB"=22, "VG"=24]).</~~lang~~>

"CH"=21, "TN"=24, "TR"=26, "AE"=23, "GB"=22, "VG"=24]).</syntaxhighlight>

Line 3,727:

===Some more (and interesting) tests===

<~~lang~~ ~~Picat~~>go2 =>

Ibans = ["GB82 WEST 1234 5698 7654 32",

"gb82 WEST 1234 5698 7654 32",

Line 3,745:

println(IBAN=iban(IBAN))

end,

nl.</~~lang~~>

nl.</syntaxhighlight>

Line 3,762:

=={{header|PicoLisp}}==

<~~lang~~ ~~Picolisp~~>(setq *Sizes '((GB . 22) (CH . 21) (SA . 24)))

<syntaxhighlight lang="picolisp">(setq *Sizes '((GB . 22) (CH . 21) (SA . 24)))

(de iban (Str)

Line 3,791:

(println 'Invalid) ) )

(bye)</~~lang~~>

(bye)</syntaxhighlight>

=={{header|PowerShell}}==

function verifIBAN ([string]$ibanS)

{

Line 3,821:

}

} #fin fonction vérification IBAN / Stéphane RABANY 2018

</syntaxhighlight>

</lang>

Ancien texte qui ne sert à rien selon moi :

I have heard that Regex should not be used with IBAN codes. Regex does seem to work, however.

@'

"Country","Length","Example"

Line 3,886:

$ibans

</syntaxhighlight>

</lang>

<pre>

Line 3,939:

United Kingdom GB 22 GB29NWBK60161331926819

</pre>

$regex = [regex]'[a-zA-Z]{2}[0-9]{2}[a-zA-Z0-9]{6}[0-9]{5}([a-zA-Z0-9]?){0,16}'

Line 3,950:

}

</syntaxhighlight>

</lang>

<pre>

Line 4,005:

=={{header|PureBasic}}==

<~~lang~~ purebasic>EnableExplicit

<syntaxhighlight lang="purebasic">EnableExplicit

Enumeration IBAN

#IBAN_VAL

Line 4,096:

ForEver

Input()

End</~~lang~~>

End</syntaxhighlight>

<pre>

Line 4,115:

=={{header|Python}}==

<~~lang~~ python>import re

<syntaxhighlight lang="python">import re

_country2length = dict(

Line 4,142:

if __name__ == '__main__':

for account in ["GB82 WEST 1234 5698 7654 32", "GB82 TEST 1234 5698 7654 32"]:

print('%s validation is: %s' % (account, valid_iban(account)))</~~lang~~>{{out}}

print('%s validation is: %s' % (account, valid_iban(account)))</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 validation is: True

GB82 TEST 1234 5698 7654 32 validation is: False

=={{header|Racket}}==

<~~lang~~ racket>#lang racket

<syntaxhighlight lang="racket">#lang racket

(define lens

'([AL 28] [AD 24] [AT 20] [AZ 28] [BH 22] [BE 16] [BA 20] [BR 29] [BG 22]

Line 4,171:

(valid-iban? "GB82 WEST 1234 5698 7654 32") ; => #t

(valid-iban? "GB82 TEST 1234 5698 7654 32") ; => #f</~~lang~~>

(valid-iban? "GB82 TEST 1234 5698 7654 32") ; => #f</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

<lang ~~perl6~~>subset IBAN of Str where sub ($_ is copy) {

<syntaxhighlight lang="raku" line>subset IBAN of Str where sub ($_ is copy) {

s:g/\s//;

return False if m/<-[ 0..9 A..Z a..z ]>/ or .chars != <

Line 4,193:

'GB82 WEST 1234 5698 7654 32',

'gb82 west 1234 5698 7654 32',

'GB82 TEST 1234 5698 7654 32';</~~lang~~>{{out}}

'GB82 TEST 1234 5698 7654 32';</syntaxhighlight>{{out}}

GB82 WEST 1234 5698 7654 32 is valid.

gb82 west 1234 5698 7654 32 is valid.

Line 4,201:

These REXX programs can validate an IBAN specified on the command line or from an internal list.

===basic checking===

<~~lang~~ rexx>/*REXX program validates an IBAN (International Bank Account Number). */

<syntaxhighlight lang="rexx">/*REXX program validates an IBAN (International Bank Account Number). */

@.=; @.1 = 'GB82 WEST 1234 5698 7654 32 '

@.2 = 'Gb82 West 1234 5698 7654 32 '

Line 4,245:

if z//97==1 then return 0 /*check if correct remainder (modulus).*/

return e 'check digits.'</~~lang~~>

return e 'check digits.'</syntaxhighlight>

<pre>

Line 4,265:

:* checks for two countries that may not be valid (as per their entry date into the IBAN system)

:* checks some countries to make sure their check digits match a specific value

<~~lang~~ rexx>/*REXX pgm validates an IBAN (International Bank Account Number), including date ranges.*/

<syntaxhighlight lang="rexx">/*REXX pgm validates an IBAN (International Bank Account Number), including date ranges.*/

@.=; @.1 = 'GB82 WEST 1234 5698 7654 32 '

@.2 = 'Gb82 West 1234 5698 7654 32 '

Line 4,318:

if z//97==1 then return 0 /*check if correct remainder (modulus).*/

return e 'check digits.'</~~lang~~>

return e 'check digits.'</syntaxhighlight>

{{out|output|text=  when using the default input,   (the run date of this program is   29-April-2013):}}

<pre>

Line 4,337:

=={{header|Ring}}==

<~~lang~~ ring>

# Project : IBAN

Line 4,390:

modnew = number(modnew) % 97

return modnew

</syntaxhighlight>

</lang>

Output:

<pre>

Line 4,402:

=={{header|Ruby}}==

<~~lang~~ ~~Ruby~~>def valid_iban? iban

<syntaxhighlight lang="ruby">def valid_iban? iban

len = {

AL: 28, AD: 24, AT: 20, AZ: 28, BE: 16, BH: 22, BA: 20, BR: 29,

Line 4,430:

p valid_iban? "GB82 WEST 1234 5698 7654 32" #=> true

p valid_iban? "GB82 TEST 1234 5698 7654 32" #=> false</~~lang~~>

p valid_iban? "GB82 TEST 1234 5698 7654 32" #=> false</syntaxhighlight>

=={{header|Rust}}==

fn main() {

for iban in [

Line 4,499:

}) == 1

}

</syntaxhighlight>

</lang>

=={{header|Scala}}==

{{libheader|Scala}}<~~lang~~ ~~Scala~~>import scala.collection.immutable.SortedMap

{{libheader|Scala}}<syntaxhighlight lang="scala">import scala.collection.immutable.SortedMap

class Iban(val iban: String) {

Line 4,546:

def apply(s: String) = new Iban(s.replaceAll( """\s""", ""))

}</~~lang~~>The test program:

}</syntaxhighlight>The test program:

<~~lang~~ ~~Scala~~>object IbanTest extends App {

<syntaxhighlight lang="scala">object IbanTest extends App {

def blackCases = """AT611904300235473201

|GB82TEST12345698765432

Line 4,644:

blackCases.lines.foreach(l => assert(!Iban(l).isValidIban))

println(s"Successfully completed; ${whiteCases.lines.size + blackCases.lines.size} cases tested, no errors.")

}</~~lang~~>

}</syntaxhighlight>

Successfully completed; 91 cases tested, no errors.

=={{header|Seed7}}==

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

include "bigint.s7i";

Line 4,705:

check("GB82 TEST 1234 5698 7654 32");

check("GB82 WEST 1243 5698 7654 32");

end func;</~~lang~~>

end func;</syntaxhighlight>

<pre>

Line 4,716:

=={{header|Sidef}}==

<~~lang~~ ruby>func valid_iban(iban) {

<syntaxhighlight lang="ruby">func valid_iban(iban) {

static len = Hash(

AD=>24, AE=>23, AL=>28, AO=>25, AT=>20, AZ=>28, BA=>20, BE=>16, BF=>27,

Line 4,746:

say valid_iban("GB82 WEST 1234 5698 7654 32") #=> true

say valid_iban("GB82 TEST 1234 5698 7654 32") #=> false</~~lang~~>

say valid_iban("GB82 TEST 1234 5698 7654 32") #=> false</syntaxhighlight>

=={{header|SNOBOL4}}==

<~~lang~~ ~~SNOBOL4~~>* IBAN - International Bank Account Number validation

<syntaxhighlight lang="snobol4">* IBAN - International Bank Account Number validation

DEFINE('ibantable()') :(iban_table_end)

ibantable

Line 4,829:

OUTPUT = "valid IBAN: " line :(read)

END</~~lang~~>

END</syntaxhighlight>

'''Output:'''

Line 4,849:

<~~lang~~ sml>(* country_code : string -> int *)

<syntaxhighlight lang="sml">(* country_code : string -> int *)

(* Get the length of a valid IBAN given the two chars long country code *)

fun country_code (str : string) : int =

Line 4,915:

IntInf.mod (number, 97) = 1

end

end handle Subscript => false | Domain => false</~~lang~~>

end handle Subscript => false | Domain => false</syntaxhighlight>

Line 4,924:

=={{header|Tcl}}==

<~~lang~~ tcl>proc verifyIBAN {iban} {

<syntaxhighlight lang="tcl">proc verifyIBAN {iban} {

# Normalize by up-casing and stripping illegal chars (e.g., space)

set iban [regsub -all {[^A-Z0-9]+} [string toupper $iban] ""]

Line 4,957:

# Verify length and modulus

return [expr {[string length $iban] == $len && $num % 97 == 1}]

}</~~lang~~>Demonstrating:

}</syntaxhighlight>Demonstrating:

<~~lang~~ tcl>set iban "GB82 WEST 1234 5698 7654 32"

<syntaxhighlight lang="tcl">set iban "GB82 WEST 1234 5698 7654 32"

puts "$iban is [expr {[verifyIBAN $iban] ? {verified} : {unverified}}]"

set not "GB42 WEST 1234 5698 7654 32"

puts "$not is [expr {[verifyIBAN $not] ? {verified} : {unverified}}]"</~~lang~~>{{out}}

puts "$not is [expr {[verifyIBAN $not] ? {verified} : {unverified}}]"</syntaxhighlight>{{out}}

<pre>GB82 WEST 1234 5698 7654 32 is verified

GB42 WEST 1234 5698 7654 32 is unverified</pre>

Line 4,968:

This does not verify the country code or the length.

<~~lang~~ bash>declare -A base36=(

<syntaxhighlight lang="bash">declare -A base36=(

[A]=10 [B]=11 [C]=12 [D]=13 [E]=14 [F]=15 [G]=16 [H]=17 [I]=18

[J]=19 [K]=20 [L]=21 [M]=22 [N]=23 [O]=24 [P]=25 [Q]=26 [R]=27

Line 5,001:

printf "%s : " "$test"

is_iban "$test" && echo yes || echo no

done</~~lang~~>

done</syntaxhighlight>

Line 5,008:

=={{header|VBA}}==

{{trans|Phix}}<~~lang~~ vb>Public nations As New Collection

{{trans|Phix}}<syntaxhighlight lang="vb">Public nations As New Collection

Private Sub init()

nations.Add 24, "AD"

Line 5,087:

test "SA03 8000 0000 6080 1016 7519", True

test "CH93 0076 2011 6238 5295 7", True

End Sub</~~lang~~>{{out}}

End Sub</syntaxhighlight>{{out}}

<pre>GB82WEST12345698765432 ok

GB82TEST12345698765432 invalid (as expected)

Line 5,095:

=={{header|VBScript}}==

Function validate_iban(s)

validate_iban = Chr(34) & s & Chr(34) & " is NOT valid."

Line 5,154:

WScript.StdOut.WriteLine validate_iban("US12 3456 7890 0987 6543 210")

WScript.StdOut.WriteLine validate_iban("GR16 0110 1250 0000 0001 2300 695X")

</syntaxhighlight>

</lang>

Line 5,175:

<~~lang~~ ecmascript>import "/big" for BigInt

<syntaxhighlight lang="ecmascript">import "/big" for BigInt

var countryCodes =

Line 5,212:

var valid = isValid.call(iban)

System.print(iban + (valid ? " may be valid" : " is not valid"))

}</~~lang~~>

}</syntaxhighlight>

Line 5,222:

=={{header|Yabasic}}==

<~~lang~~ ~~Yabasic~~>// List updated to release 72, 25 November 2016, of IBAN Registry (75 countries)

<syntaxhighlight lang="yabasic">// List updated to release 72, 25 November 2016, of IBAN Registry (75 countries)

countryCodes$ = "AD24 AE23 AL28 AT20 AZ28 BA20 BE16 BG22 BH22 BR29 BY28 CH21 CR22 CY28 CZ24 DE22 "

countryCodes$ = countryCodes$ + "DK18 DO28 EE20 ES24 FI18 FO18 FR27 GB22 GE22 GI23 GL18 GR27 GT28 HR21 HU28 IE22 "

Line 5,294:

test("GB81 WEST 1234 5698 7654 32", false)

test("SA03 8000 0000 6080 1016 7519", true)

test("CH93 0076 2011 6238 5295 7", true)</~~lang~~>

test("CH93 0076 2011 6238 5295 7", true)</syntaxhighlight>

=={{header|zkl}}==

Using GMP big nums:

<~~lang~~ zkl>var BN=Import("zklBigNum");

<syntaxhighlight lang="zkl">var BN=Import("zklBigNum");

fcn validateIBAN(iban){

iban=iban-" \t";

alphaNums.matches(iban) and (ibans.find(iban[0,2])==iban.len()) and

( BN((iban[4,*]+iban[0,4]).apply("toInt",36)) % 97 == 1 )

}</~~lang~~>Without using big nums:

}</syntaxhighlight>Without using big nums:

<~~lang~~ zkl>fcn validateIBAN(iban){

<syntaxhighlight lang="zkl">fcn validateIBAN(iban){

iban=iban-" \t";

alphaNums.matches(iban) and (ibans.find(iban[0,2])==iban.len()) and

Line 5,315:

}

M

}</~~lang~~><lang zkl>var alphaNums=RegExp("^[0-9A-Z]+$");

}</syntaxhighlight><syntaxhighlight lang="zkl">var alphaNums=RegExp("^[0-9A-Z]+$");

var ibans= // Dictionary("AD":24, ...)

("AD24 AE23 AL28 AO25 AT20 AZ28 BA20 BE16 BF27 BG22 BH22 BI16 "

Line 5,324:

"MR27 MT31 MU30 MZ25 NL18 NO15 PK24 PL28 PS29 PT25 QA29 RO24 "

"RS22 SA24 SE24 SI19 SK24 SM27 SN28 TN24 TR26 UA29 VG24")

.split(" ").pump(D(),fcn(w){return(w[0,2],w[2,*].toInt())});</~~lang~~>Testing 1 2 3

.split(" ").pump(D(),fcn(w){return(w[0,2],w[2,*].toInt())});</syntaxhighlight>Testing 1 2 3

<~~lang~~ zkl> // all valid

<syntaxhighlight lang="zkl"> // all valid

T("GB82 WEST 1234 5698 7654 32","GB82WEST12345698765432",

"GR16 0110 1250 0000 0001 2300 695","GB29 NWBK 6016 1331 9268 19",

Line 5,344:

...

"CH9300762011623852957").split()

.apply(validateIBAN).toString(*).println();</~~lang~~>

.apply(validateIBAN).toString(*).println();</syntaxhighlight>

<pre>

Line 5,360:

=={{header|ZX Spectrum Basic}}==

<~~lang~~ zxbasic>10 REM REM Used the following as official standard:

<syntaxhighlight lang="zxbasic">10 REM REM Used the following as official standard:

20 REM REM http://www.cnb.cz/cs/platebni_styk/iban/download/EBS204.pdf

30 REM REM Pairs of ISO 3166 country code & expected IBAN length for this country

Line 5,423:

4050 NEXT i

4060 RETURN

5000 DEF FN m(a,b)=a-INT (a/b)*b: REM modulo</~~lang~~>

5000 DEF FN m(a,b)=a-INT (a/b)*b: REM modulo</syntaxhighlight>