Basic Bank Account Number
Pour les articles homonymes, voir RIB.
Le Basic Bank Account Number (BBAN, litt. « numéro de compte bancaire basique ») ou relevé d'identité bancaire (RIB), en France, ou encore spécimen de chèque (Québec) est une suite de chiffres délivré par la banque et qui indique de manière unique un compte bancaire au niveau national. Il est remis à un débiteur ou un créancier dans le but d'opérer des virements bancaires ou des prélèvements bancaires à partir de ce compte. Ces éléments sont souvent présents sur les chèques.
Remplacement du RIB par l'IBAN
modifierLa notion de RIB a été officiellement abolie avec le passage au format SEPA[2], c'est à dire que l'ancien format et la façon dont le RIB était utilisé sont devenus obsolètes. Désormais, dans le cadre du SEPA, ce sont les informations contenues dans l'IBAN et le BIC qui sont utilisées pour les transactions bancaires. Néanmoins le terme "RIB" est encore largement utilisée pour désigner l'ensemble des informations bancaires, même si, techniquement, ce n'est plus le format requis pour les opérations SEPA. Il est aussi parfois, à tort, utilisé pour désigner l'IBAN (International Bank Account Number) qui permet d'identifier un compte à l'international. Aujourd'hui les comptes bancaires français disposent du relevé d'identité bancaire qui comporte : l'IBAN, le BIC, le code banque, code guichet, numéro du compte et clé RIB (ces quatre dernières information sont parfois regroupées sous le nom de code RIB), le nom et prénom du titulaire et la domiciliation du compte (nom de la banque et de l’agence)[3],[4]. En Europe, l'IBAN est suffisant pour opérer des opérations bancaires SEPA (prélèvement et virement)[5].
En France, l'IBAN est inscrit sur le relevé de compte du compte en question[6].
Législation
modifierLa réglementation SEPA entraîne l'impossibilité d'utiliser le RIB pour des opérations bancaires, l'IBAN étant nécessaire et suffisant. Les virements et prélèvements nationaux et européens sont soumis aux mêmes frais et aux mêmes droits et devoirs. Il est également possible d'utiliser l'IBAN d'un autre pays européen dans son propre pays.
Les établissements de crédit (BNP Paribas, Société générale, Crédit agricole…), les établissements de paiement (Nickel par exemple) ainsi que les établissements de monnaie électronique (PayPal, Treezor…) ont la faculté de délivrer des IBAN.
Composition
modifier| Composition du BBAN | |||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 3 à 12 positions | 8 à 20 positions | ||||||||||||||||||||||||||||||
| IID | BAN | ||||||||||||||||||||||||||||||
- IID : identification de l’établissement financier
- BAN : numéro de compte bancaire
Il n'a pas plus de 30 positions. Chaque pays a la responsabilité de définir le format de son BBAN.
Exemples
modifier- B = code banque (5 chiffres), G = code guichet (5 chiffres), C = numéro de compte (11 chiffres et/ou lettres), K = clé RIB (2 chiffres entre 01 et 97)
- Belgique (12 chiffres) Format : BBBCCCCCCCKK
- B = code banque (3 chiffres), C = numéro de compte (7 chiffres), KK = BBBCCCCCCC modulo 97 (si égal à 0, KK = 97)
- Allemagne (18 chiffres) Format BBBBBBBBCCCCCCCCCC
- B = code banque (8 chiffres), C = numéro de compte (10 chiffres. Si moins, compléter à gauche avec des 0)
- Nota: le numéro de compte allemand (C) contient une clé de contrôle, mais sa position et son calcul diffèrent d'une banque à l'autre. Il existe plus de 100 méthodes différentes de calcul de la clé en Allemagne (source : de:Kontonummer)
Clé RIB
modifierClé = 97 − ([concaténation de banque, guichet, compte] * 100 modulo 97). Cette clé est proche de celle du numéro de Sécurité sociale français, à la différence qu'il n'est pas centuplé. Si le compte comporte des lettres (banques françaises Banque postale et Crédit lyonnais), remplacer la lettre par son index de 1 à 9 dans l'alphabet ( etc.) en laissant un saut entre R et S ( ).
Calcul de la Clef RIB en Java
modifier public int getRibKey(String rib) {
StringBuilder extendedRib = new StringBuilder(rib.length());
for (char currentChar : rib.toCharArray()) {
//Works on base 36
int currentCharValue = Character.digit(currentChar, Character.MAX_RADIX);
//Convert character to simple digit
extendedRib.append(currentCharValue<10?currentCharValue:(currentCharValue + (int) StrictMath.pow(2,(currentCharValue-10)/9))%10);
}
BigDecimal extendedRibInt = new BigDecimal(extendedRib.toString());
return 97- extendedRibInt.multiply(new BigDecimal(100)).toBigInteger().mod(new BigDecimal(97).toBigInteger()).intValue();
}
Le chéquier
modifierLe relevé d'identité bancaire, sur le carnet de chèque, est composé de :
- l'International Banking Account Number (IBAN), numéro de compte à la norme internationale ISO n° 13616
- le Bank Identification Code (BIC), identifiant de l'établissement financier (la banque) à la norme internationale ISO n° 9362
- le nom et l'adresse du titulaire du compte, en date d'établissement du carnet de chèque (les chèques restant valides après déménagement)
- le nom de l'établissement financier (la banque) et du guichet de domiciliation (l'agence bancaire)
Vérification du RIB
modifierAlgorithme
modifierLa validité d'un RIB se calcule grâce à la clé de celui-ci.
La première étape consiste à remplacer les lettres présentes par des chiffres pour faciliter le calcul.
| Caractère | Chiffre représentant |
|---|---|
| 0 | 0 |
| 1, A, J | 1 |
| 2, B, K, S | 2 |
| 3, C, L, T | 3 |
| 4, D, M, U | 4 |
| 5, E, N, V | 5 |
| 6, F, O, W | 6 |
| 7, G, P, X | 7 |
| 8, H, Q, Y | 8 |
| 9, I, R, Z | 9 |
Pour faire la transformation, il suffit de se placer en base 36 (base 10 + 26 lettres) et d'appliquer le calcul suivant sur chaque caractère (transformé en nombre currentCharValue) puis de remplacer le sélectionné par le nombre donné :
L'étape suivante (facultative) consiste à décomposer le code et multiplier chaque partie par une constante et en faire la somme. Enfin, le code est correct si le nombre obtenu (soit par simple concaténation de nos différentes parties, soit par décomposition) est congru à 0 modulo 97.
Vérification du RIB en C#
modifierLa fonction check_rib retourne vrai ou faux en fonction de la validité des informations.
private static Regex regex_rib;
/// <summary>
/// Vérifie la validité d'un RIB
/// </summary>
/// <param name="rib">Le RIB à vérifier</param>
/// <returns>true si le RIB est valide, false sinon</returns>
public static bool IsValidRib(string rib)
{
// Suppression des espaces et tirets
string tmp = rib.Replace(" ", "").Replace("-", "");
// Vérification du format BBBBBGGGGGCCCCCCCCCCCKK
// B : banque
// G : guichet
// C : numéro de compte
// K : clé RIB
if (regex_rib == null)
{
regex_rib = new Regex(@"(?<B>\d{5})(?<G>\d{5})(?<C>\w{11})(?<K>\d{2})", RegexOptions.Compiled);
}
Match m = regex_rib.Match(tmp);
if (!m.Success)
return false;
// Extraction des composants
string b_s = m.Groups["B"].Value;
string g_s = m.Groups["G"].Value;
string c_s = m.Groups["C"].Value;
string k_s = m.Groups["K"].Value;
// Remplacement des lettres par des chiffres dans le numéro de compte
StringBuilder sb = new StringBuilder();
foreach (char ch in c_s.ToUpper())
{
if (char.IsDigit(ch))
sb.Append(ch);
else
sb.Append(RibLetterToDigit(ch));
}
c_s = sb.ToString();
// Séparation du numéro de compte pour tenir sur 32bits
string d_s = c_s.Substring(0, 6);
c_s = c_s.Substring(6, 5);
// Calcul de la clé RIB
int b = int.Parse(b_s);
int g = int.Parse(g_s);
int d = int.Parse(d_s);
int c = int.Parse(c_s);
int k = int.Parse(k_s);
int calculatedKey = 97 - ((89 * b + 15 * g + 76 * d + 3 * c) % 97);
return (k == calculatedKey);
}
/// <summary>
/// Convertit une lettre d'un RIB en un chiffre selon la table suivante :
/// 1 2 3 4 5 6 7 8 9
/// A B C D E F G H I
/// J K L M N O P Q R
/// _ S T U V W X Y Z
/// </summary>
/// <param name="letter">La lettre à convertir</param>
/// <returns>Le chiffre de remplacement</returns>
public static char RibLetterToDigit(char letter)
{
if (letter >= 'A' && letter <= 'I')
{
return (char)(letter - 'A' + '1');
}
else if (letter >= 'J' && letter <= 'R')
{
return (char)(letter - 'J' + '1');
}
else if (letter >= 'S' && letter <= 'Z')
{
return (char)(letter - 'S' + '2');
}
else
throw new ArgumentOutOfRangeException("Le caractère à convertir doit être une lettre majuscule dans la plage A-Z");
}
Vérification du RIB en Java
modifierimport java.math.BigDecimal;
public class Validation{
public boolean checkRib(String rib) {
StringBuilder extendedRib = new StringBuilder(rib.length());
for (char currentChar : rib.toCharArray()) {
int intValue;
if ('0' <= currentChar && currentChar <= '9') {
intValue = currentChar - '0';
} else if ('A' <= currentChar && currentChar <= 'I') {
intValue = currentChar - 'A' + 1;
} else if ('J' <= currentChar && currentChar <= 'R') {
intValue = currentChar - 'J' + 1;
} else if ('S' <= currentChar && currentChar <= 'Z') {
intValue = currentChar - 'S' + 2;
} else {
return false;
}
extendedRib.append(intValue);
}
return new BigDecimal(extendedRib.toString()).remainder(new BigDecimal(97)).intValue() == 0;
}
}
Vérification du RIB en Perl
modifierAvec :
- $cbanque : code de la banque
- $cguichet : code du guichet
- $nocompte : numéro de compte
- $clerib : clé rib
use Math::BigInt;
my %letter_substitution = ("A" => 1, "B" => 2, "C" => 3, "D" => 4, "E" => 5, "F" => 6, "G" => 7, "H" => 8, "I" => 9,
"J" => 1, "K" => 2, "L" => 3, "M" => 4, "N" => 5, "O" => 6, "P" => 7, "Q" => 8, "R" => 9,
"S" => 2, "T" => 3, "U" => 4, "V" => 5, "W" => 6, "X" => 7, "Y" => 8, "Z" => 9);
my $tabcompte = "";
my $len = length($nocompte);
return 0 if ($len != 11);
for (my $i = 0; $i < $len; $i++) {
my $car = substr($nocompte, $i, 1);
if ($car !~ m/^\d$/) {
my $b = $letter_substitution{uc($car)};
my $c = ( $b + 2**(($b - 10)/9) ) % 10;
$tabcompte .= $c;
} else {
$tabcompte .= $car;
}
}
my $int = "$cbanque$cguichet$tabcompte$clerib";
return (length($int) >= 21 && Math::BigInt->new($int)->bmod(97) == 0) ? 1 : 0;
Vérification du RIB en PHP
modifierLa fonction check_rib retourne vrai ou faux en fonction de la validité des informations.
function check_rib($cbanque, $cguichet, $nocompte, $clerib) {
$tabcompte = "";
$len = strlen($nocompte);
if ($len != 11) {
return false;
}
for ($i = 0; $i < $len; $i++) {
$car = substr($nocompte, $i, 1);
if (!is_numeric($car)) {
$c = ord($car) - (ord('A') - 1);
$b = (($c + pow ( 2, ($c - 10) / 9 )) % 10) + (($c > 18 && $c < 25) ? 1 : 0);
$tabcompte .= $b;
}
else {
$tabcompte .= $car;
}
}
$int = $cbanque . $cguichet . $tabcompte . $clerib;
return (strlen($int) >= 21 && bcmod($int, 97) == 0);
}
Vérification du RIB en Python
modifierdef check_rib(rib):
if len(rib) != 23:
return False
_RIB_MAP = {
'A':'1', 'B':'2', 'C':'3', 'D':'4', 'E':'5', 'F':'6', 'G':'7', 'H':'8', 'I':'9',
'J':'1', 'K':'2', 'L':'3', 'M':'4', 'N':'5', 'O':'6', 'P':'7', 'Q':'8', 'R':'9',
'S':'2', 'T':'3', 'U':'4', 'V':'5', 'W':'6', 'X':'7', 'Y':'8', 'Z':'9',
}
values = "".join(_RIB_MAP.get(char.upper(), char) for char in rib)
if not values.isdigit():
return False
bankcode = int(values[:5])
counter = int(values[5:10])
account = int(values[10:21])
key = int(values[21:])
return (bankcode*89 + counter*15 + account*3 + key) % 97 == 0
Vérification du RIB en Ruby
modifierAvec :
- rib : le RIB complet sans espace à passer à la méthode.
def rib?(rib)
bank, office, account, key = rib.match(/^(\d{5})(\d{5})([[:alnum:]]{11})(\d{2})$/).captures
account = account.each_char.inject('') do |sum, char|
char = char.to_i 36
sum += ((char + 2 ** ((char - 10)/9)).to_i % 10).to_s
end
result = bank + office + account + key
result.size >= 21 && result.to_i % 97 == 0
rescue
# Le RIB n’est pas valide
false
end
Vérification du RIB en SQL
modifierCette vérification permet de valider la saisie de l'utilisateur, qui renseigne à l'exécution de la requête SQL les codes Banque, Guichet et numéro de compte, ou de lui demander une nouvelle saisie.
select Saisie.*
,97-mod(Banque*89+Guichet*15+Compte*3,97) CleRIB
from (select substr(lpad(&Banque,5,'0'),1,5) Banque
,substr(lpad(&Guichet,5,'0'),1,5) Guichet
,translate(upper(substr(lpad('&Compte',11,'0'),1,11))
,'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
, 12345678912345678923456789
) Compte
from dual
) Saisie;
Vérification du RIB en SQL pour Oracle
modifierCette vérification permet de vérifier un grand nombre de RIB, dans une table RIB_payment
CREATE TABLE ( rib_id NUMBER(10)
, rib_banque VARCHAR2(12)
CONSTRAINT rib_banque_nn_payment NOT NULL NOT NULL
, rib_guichet VARCHAR2(12)
CONSTRAINT rib_guichet_nn_payment NOT NULL
, rib_compte VARCHAR2(20)
CONSTRAINT rib_compte_nn_payment NOT NULL
, rib_cle VARCHAR2(3)
, rib_saisie_date DATE DEFAULT SYSDATE
CONSTRAINT rib_saisie_date_nn_payment NOT NULL
, person_id VARCHAR2(10)/*titulaire, personne morale ou physique*/
CONSTRAINT rib_person_id_nn_payment NOT NULL
, CONSTRAINT rib_person_id_uk_payment
UNIQUE (person_id)
)
saisie au préalable, et en relation avec une table des personnes (personnes physiques ou personnes morales).
SELECT IBAN,
MOD(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(
REPLACE( REPLACE( substr(IBAN,5,length(IBAN))||substr(IBAN,1,4)
,'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'),'S','28'),'T','29')
,'U','30'),'V','31'),'W','32'),'X','33'),'Y','34')
,'Z','35') ,' ','')
,97) IBAN_modulo
FROM COMPTE
La requête contrôle le IBAN (on peut facilement le construire à partir du RIB).
Vérification du RIB en VBA
modifierCe code fonctionne sous Excel, l'abréviation « VBE » étant la contraction de VBA pour Excel.
Ces fonctions permettent de vérifier la validité d'un RIB
Function Mod97(Numero As String) As Integer
' Calcule le modulo 97 du numéro donné
Dim Nro As String
Dim a As Variant, b As Variant, c As Variant, d As Variant, e As Variant, div97 As Variant
Nro = Numero
a = 0
b = 0
c = 0
e = Right(Nro, 6)
d = Mid(Nro, Len(Nro) - 11, 6)
Select Case Len(Nro)
Case 13 To 20
c = CDbl(Mid(Nro, 1, Len(Nro) - 12))
Case 21 To 28
c = CDbl(Mid(Nro, Len(Nro) - 19, 8))
If Len(Nro) <> 20 Then b = CDbl(Mid(Nro, 1, Len(Nro) - 20))
Case 29 To 38
c = CDbl(Mid(Nro, Len(Nro) - 19, 8))
b = CDbl(Mid(Nro, Len(Nro) - 27, 8))
a = CDbl(Mid(Nro, 1, Len(Nro) - 28))
Case Else
Mod97 = 0
Exit Function
End Select
div97 = Int((a * 93 + b * 73 + c * 50 + d * 27 + e Mod 97) / 97)
Mod97 = (a * 93 + b * 73 + c * 50 + d * 27 + e Mod 97) - div97 * 97
End Function
Function ControleRib(cbanque As String, cguichet As String, nocompte As String, clerib As String)
Const transforme = "12345678912345678923456789"
Dim tabcompte As String, lg As Long, i As Long, car As String, c As Integer, rib_int As String
tabcompte = ""
lg = Len(nocompte)
If lg <> 11 Then
ControleRib = False
Else
For i = 1 To lg
car = Mid(nocompte, i, 1)
If Not IsNumeric(car) Then
c = asc(car) - (asc("A") - 1)
tabcompte = tabcompte & Mid(transforme, c, 1)
Else
tabcompte = tabcompte & car
End If
Next i
rib_int = cbanque & cguichet & tabcompte & clerib
ControleRib = (Len(rib_int) >= 21) And (Mod97(rib_int) = 0)
End If
End Function
Il faut insérer ces deux fonctions dans un module dans visual basic editor (EXCEL ou ACCESS) et faire l'appel depuis :
1. Excel :
=ControleRib(A1, A2, A3, A4)
Où A1, A2, A3 et A4 doivent contenir les 4 valeurs composant le RIB (RIB_Banque, RIB_Guichet, RIB_Compte, RIB_Cle)
2. Access :
If ControleRib(RIB_Banque, RIB_Guichet, RIB_Compte, RIB_Cle) Then
TESTRIB = "RIB CORRECT"
MsgBox " RIB EST CORRECT", vbInformation, "VERIF RIB"
Else
TESTRIB = "RIB ERRONE"
MsgBox " LE RIB EST ERRONE", vbCritical, "VERIF RIB"
End If
Où RIB_Banque, RIB_Guichet, RIB_Compte, RIB_Cle sont les noms des zones de texte qui doivent contenir le RIB et TESTRIB est le nom de la zone de texte qui devra afficher le résultat du test.
Vérification du RIB en VB.NET
modifier Private Function textetochiffre(ByVal numero As String) As Integer
If IsNumeric(numero) = False Then
numero = Asc(numero) - 55
End If
Return Math.Floor((numero + Math.Pow(2, (numero - 10) / 9)) Mod 10)
End Function
Private Function verifierrib(ByVal plainrib As String)
Dim rib As String = ""
For i = 0 To plainrib.Count - 1
rib = rib & textetochiffre(plainrib.Substring(i, 1))
Next
Dim banknote As String = rib.Substring(0, 5)
Dim guichet As String = rib.Substring(5, 5)
Dim compte As String = rib.Substring(10, 11)
Dim clerib As String = rib.Substring(21, 2)
Dim result As Integer = (banknote * 89 + guichet * 15 + compte * 3 + clerib) Mod 97
If result = 0 Then
Return True
Else
Return False
End If
End Function
Conversion du RIB en IBAN
modifierAlgorithme
modifier- Créer un IBAN temporaire, composé du code du pays : FR pour la France, suivi de " 00 " et du " code RIB "
- Déplacer les 4 premiers caractères de l’IBAN vers la droite du numéro.
- Convertir les lettres en chiffres, selon le principe "A" vaut "10" ... "Z" vaut "35".
- Calculer le modulo 97 et retrancher le reste de 98. Si le résultat comporte un seul chiffre, insérer un zéro devant.
Insérer le résultat ainsi obtenu à la position 3 de l’IBAN temporaire créé dans l’étape 1.
Conversion du RIB en IBAN en C#
modifierpublic static string GetIban(string codebanque, string codeGuichet, string numerocompte, string cle)
{
const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var tmp = (codebanque + codeGuichet + numerocompte + cle + "FR00").ToUpper();
foreach (var c in tmp.Where(char.IsLetter))
{
tmp = tmp.Replace(c.ToString(CultureInfo.InvariantCulture), (alphabet.IndexOf(c) + 10).ToString(CultureInfo.InvariantCulture));
}
var ibanKey = (98 - (System.Numerics.BigInteger.Parse(tmp) % 97)).ToString(CultureInfo.InvariantCulture);
return "FR" + ((ibanKey.Length == 1) ? "0" : "") + ibanKey + codebanque + codeGuichet + numerocompte + cle;
}
Conversion du RIB en IBAN en Java
modifierpublic static String getIBAN(String codebanque, String codeGuichet, String numerocompte, String cle) {
String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String tmp = codebanque + codeGuichet + numerocompte + cle + "FR00";
tmp = tmp.toUpperCase();
for (char c : tmp.toCharArray()) {
if (Character.isLetter(c)) {
tmp = tmp .replaceAll(String.valueOf(c), String.valueOf(alphabet.indexOf(c) + 10));
}
}
String ibanKey =
String.valueOf(new BigDecimal(98).subtract(new BigDecimal(tmp).remainder((new BigDecimal(97)))));
if (ibanKey.length() == 1) {
ibanKey = "0" + ibanKey;
}
return "FR" + ibanKey + codebanque + codeGuichet + numerocompte + cle;
}
Conversion du RIB en IBAN en Perl
modifieruse bigint;
sub rib_to_iban {
my ($rib) = @_;
my @letter = ('0'..'9','A'..'Z');
my $iban = "";
foreach my $char(split(//,"${rib}FR00")) {
my ($index) = grep { $letter[$_] eq $char } (0 .. @letter-1);
$iban .= $index;
}
my $key = 98 - ($iban % 97);
return sprintf("FR%.2d%s" ,$key, $rib);
}
Conversion du RIB en IBAN en PHP
modifierfunction Rib2Iban($codebanque,$codeguichet,$numerocompte,$cle){
$charConversion = array("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","S" => "28","T" => "29","U" => "30","V" => "31","W" => "32","X" => "33","Y" => "34","Z" => "35");
$tmpiban = strtr(strtoupper($codebanque.$codeguichet.$numerocompte.$cle)."FR00",$charConversion);
// Soustraction du modulo 97 de l'IBAN temporaire à 98
$cleiban = strval(98 - intval(bcmod($tmpiban,"97")));
if (strlen($cleiban) == 1)
$cleiban = "0".$cleiban;
return "FR".$cleiban.$codebanque.$codeguichet.$numerocompte.$cle;
}
Conversion du RIB en IBAN en Python
modifierAvec :
- rib : le RIB complet sans espace à passer à la méthode.
def rib_to_iban(rib):
tmp_iban = int("".join(str(int(c,36)) for c in rib+"FR00"))
key = 98 - (tmp_iban % 97)
return "FR%.2d%s" % (key, rib)
Conversion du RIB en IBAN en Ruby
modifierAvec :
- rib : le RIB complet sans espace à passer à la méthode.
def rib_to_iban(rib)
tmp_iban = "#{rib}FR00".each_char.map { |char| char.to_i(36).to_s }.join.to_i
key = 98 - (tmp_iban % 97)
"FR%.2d%s" % [key, rib]
end
Conversion du RIB en IBAN en SQL
modifier Conversion du RIB en IBAN en SQL Server 2008 R2 (Microsoft)
modifier-- Creates an IBAN (International Bank Account Number) from a BBAN (Basic Bank Account Number) and BIC (Bank Identifier Code)
-- SQL 2008 R2
-- Tested on several SEPA countries
CREATE FUNCTION [dbo].[SQL_F_BBAN_IBAN] (@bban varchar(30), @bic varchar(11))
RETURNS varchar(40)
AS
-- Creates an IBAN (International Bank Account Number) from a BBAN (Basic Bank Account Number) and BIC (Bank Identifier Code)
-- In : BBAN, BIC
-- Returns : IBAN
BEGIN
declare @bbanwk varchar(60), @country char(2), @bbannbp int, @bbanp varchar(9), @pos smallint, @mod int, @i smallint, @keyiban char(2), @iban varchar(40)
-- Get the country code from the BIC
set @country = substring(@bic, 5, 2)
-- Place it at the end of BBAN
set @bbanwk = @bban + @country + '00'
-- Replace any letters with their numeric value (code ASCII - 55)
while isnumeric(@bbanwk+'e0') = 0
BEGIN
set @pos = (select patindex('%[^0-9]%',@bbanwk))
set @bbanwk = (select replace(@bbanwk,substring(@bbanwk,@pos,1),ascii(substring(@bbanwk,@pos,1))-55))
END
-- Split the BBAN into parts of 9 numbers max (because too long for SQL data type INT) and calculate MOD 97 of each part
-- suppose to add 1 iteration each 4 iteration, so init @i = 0 and not 1 for some case.
set @bbannbp = ceiling(len(@bbanwk) / 9.0)
set @pos = 10
set @i = 0
set @bbanp = left(@bbanwk, 9)
while @i <= @bbannbp
BEGIN
set @mod = cast(@bbanp as int) % 97
-- Put the result at the beginning of the next group
set @bbanp = cast(@mod as varchar) + substring(@bbanwk, @pos, 7)
set @i = @i + 1
set @pos = @pos + 7
END
-- IBAN key 2 characters
set @keyiban = right('00' + cast((98 - @mod) as varchar), 2)
set @iban = @country + @keyiban + @bban
RETURN @iban
END
GO
Conversion du RIB en IBAN en SQL pour Oracle
modifierFUNCTION SO_F_RIB_IBAN(pi_va_rib IN VARCHAR2) RETURN VARCHAR2
IS
l_i_loop INTEGER;
l_va_return VARCHAR2(40);
l_n_clee INTEGER;
BEGIN
l_va_return := UPPER(pi_va_rib) || 'FR00';
-- Transformation de A-Z en 10-35
FOR l_i_loop IN 0 .. 25 LOOP
l_va_return := REPLACE(l_va_return, CHR(65+l_i_loop), (10+l_i_loop));
END LOOP;
-- Soustraction du modulo 97 de l'IBAN temporaire à 98
l_n_clee := (98 - MOD(l_va_return,97));
-- Retourne l'iban
RETURN 'FR' || TRIM(TO_CHAR(l_n_clee, '00')) || UPPER(pi_va_rib);
END SO_F_RIB_IBAN;
Conversion du RIB en IBAN en VBA
modifierCe code fonctionne sous Excel, l'abréviation « VBE » étant la contraction de VBA pour Excel.
Conversion du RIB en IBAN en VB.NET
modifierPublic Function GetIBAN(rib As String) As String
rib = rib.Replace(" ", "")
Dim tmpIBAN As New StringBuilder()
For Each c As Char In (rib + "FR00").ToUpper()
Dim v As Integer = Asc(c) + If(c >= "A"c, -Asc("A") + 10, -Asc("0"))
tmpIBAN.Append(v)
Next
Dim tmpIBANString As String = tmpIBAN.ToString()
Dim checksum As Integer = 0
For Each c In tmpIBANString
checksum *= 10
checksum += Integer.Parse(c)
checksum = checksum Mod 97
Next
Dim ibanKey As String = (98 - checksum).ToString()
Return "FR" + Right("0" & ibanKey, 2) + rib
End Function
Conversion du RIB en IBAN en JavaScript
modifierfunction GetIban(codeBanque, codeGuichet, numCompte, cleRib) {
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var tmp = "";
tmp = "" + String(codeBanque) + String(codeGuichet) + String(numCompte) + String(cleRib) + "FR00";
tmp = tmp.toUpperCase();
tmp = tmp.split("");
for (var i = 0; i < tmp.length; i++) {
if (alphabet.indexOf(tmp[i]) != -1) {
tmp[i] = String(alphabet.indexOf(tmp[i]) + 10);
}
}
tmp = tmp.join("");
var moduloRemainder = parseInt(tmp % 97, 10);
var ibanKey = (98 - moduloRemainder).toString();
if (ibanKey.length == 1) {
ibanKey = "0" + ibanKey;
}
return "FR" + ibanKey + codeBanque + codeGuichet + numCompte + cleRib;
};
Notes et références
modifier- « Master of the Playing Cards », dans Benezit Dictionary of Artists, Oxford University Press, (lire en ligne)
- « Prélèvements : le RIB cède la place aux normes SEPA », sur Le Monde.fr, (consulté le )
- Alexiane Turcant, « Tout savoir sur le RIB : Définition et Utilisation », sur selectra.info, (consulté le )
- « RIB, IBAN et BIC : les petits noms de vos coordonnées bancaires », sur www.banque-france.fr, (consulté le )
- « REGLEMENT (UE) No260/2012 DU PARLEMENT EUROPÉEN ET DU CONSEIL »
- « Article R351-5 du code monétaire », sur legifrance.gouv.fr
