Aller au contenu

Wikipédia l'encyclopédie libre

Basic Bank Account Number

Modifier les liens

Un article de Wikipédia, l'encyclopédie libre.

Page d’aide sur l’homonymie

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

[modifier | modifier le code ]

En France

[modifier | modifier le code ]

La notion de RIB a été officiellement abolie avec le passage au format SEPA ^[1], 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)^[2]^,^[3]. En Europe, l'IBAN est suffisant pour opérer des opérations bancaires SEPA (prélèvement et virement)^[4].

En France, l'IBAN est inscrit sur le relevé de compte du compte en question^[5].

Législation

[modifier | modifier le code ]

La 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 | modifier le code ]

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 | modifier le code ]

France et Monaco (23 caractères) Format : BBBBBGGGGGCCCCCCCCCCCKK

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

[modifier | modifier le code ]

Article détaillé : Clé RIB.

Clé = 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 ( $A=1,\ \ldots ,\ I=9,\ J=1,\$ {\displaystyle A=1,\ \ldots ,\ I=9,\ J=1,\ }etc.) en laissant un saut entre R et S ( $R=9,\ S=2$ {\displaystyle R=9,\ S=2}).

Calcul de la Clef RIB en Java

[modifier | modifier le code ]

publicstaticintgetRibKey(Stringrib)
{
StringBuilderextendedRib=newStringBuilder(rib.length());
for(charcurrentChar:rib.toCharArray())
{
//Works on base 36
intcurrentCharValue=Character.digit(currentChar,36);
//Convert character to simple digit
extendedRib.append(currentCharValue<10?currentCharValue:(currentCharValue+(1<<((currentCharValue-10)/9)))%10);
}
BigIntegerextendedRibInt=newBigInteger(extendedRib.toString());
return97-extendedRibInt.multiply(BigInteger.valueOf(100)).mod(BigInteger.valueOf(97)).intValue();
}

Le chéquier

[modifier | modifier le code ]

Le 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

[modifier | modifier le code ]

Algorithme

[modifier | modifier le code ]

La 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.

Tableau de transformation des caractères
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é :

${\text{currentCharValue}}+2^{\frac {{\text{currentCharValue}}-10}{9}}{\pmod {10}}$ {\displaystyle {\text{currentCharValue}}+2^{\frac {{\text{currentCharValue}}-10}{9}}{\pmod {10}}}

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.

${\text{bankCode}}*89+{\text{counter}}*15+{\text{account}}*3+{\text{key}}\equiv 0{\pmod {97}}$ {\displaystyle {\text{bankCode}}*89+{\text{counter}}*15+{\text{account}}*3+{\text{key}}\equiv 0{\pmod {97}}}

Vérification du RIB en C#

[modifier | modifier le code ]

La fonction check_rib retourne vrai ou faux en fonction de la validité des informations.

Code source en C#

privatestaticRegexregex_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>
publicstaticboolIsValidRib(stringrib)
{
// Suppression des espaces et tirets
stringtmp=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=newRegex(@"(?<B>\d{5})(?<G>\d{5})(?<C>\w{11})(?<K>\d{2})",RegexOptions.Compiled);
}
Matchm=regex_rib.Match(tmp);
if(!m.Success)
returnfalse;

// Extraction des composants
stringb_s=m.Groups["B"].Value;
stringg_s=m.Groups["G"].Value;
stringc_s=m.Groups["C"].Value;
stringk_s=m.Groups["K"].Value;

// Remplacement des lettres par des chiffres dans le numéro de compte
StringBuildersb=newStringBuilder();
foreach(charchinc_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
stringd_s=c_s.Substring(0,6);
c_s=c_s.Substring(6,5);

// Calcul de la clé RIB

intb=int.Parse(b_s);
intg=int.Parse(g_s);
intd=int.Parse(d_s);
intc=int.Parse(c_s);
intk=int.Parse(k_s);

intcalculatedKey=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>
publicstaticcharRibLetterToDigit(charletter)
{
if(letter>='A'&&letter<='I')
{
return(char)(letter-'A'+'1');
}
elseif(letter>='J'&&letter<='R')
{
return(char)(letter-'J'+'1');
}
elseif(letter>='S'&&letter<='Z')
{
return(char)(letter-'S'+'2');
}
else
thrownewArgumentOutOfRangeException("Le caractère à convertir doit être une lettre majuscule dans la plage A-Z");
}

Algorithme de clé RIB | developpez.com

Vérification du RIB en Java

[modifier | modifier le code ]

importjava.math.BigDecimal;
publicclass Validation{
publicbooleancheckRib(Stringrib){
StringBuilderextendedRib=newStringBuilder(rib.length());
for(charcurrentChar:rib.toCharArray()){
intintValue;
if('0'<=currentChar&&currentChar<='9'){
intValue=currentChar-'0';
}elseif('A'<=currentChar&&currentChar<='I'){
intValue=currentChar-'A'+1;
}elseif('J'<=currentChar&&currentChar<='R'){
intValue=currentChar-'J'+1;
}elseif('S'<=currentChar&&currentChar<='Z'){
intValue=currentChar-'S'+2;
}else{
returnfalse;
}
extendedRib.append(intValue);
}
returnnewBigDecimal(extendedRib.toString()).remainder(newBigDecimal(97)).intValue()==0;
}
}

Vérification du RIB en Perl

[modifier | modifier le code ]

Avec :

$cbanque : code de la banque
$cguichet : code du guichet
$nocompte : numéro de compte
$clerib : clé rib

useMath::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);
return0if($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

[modifier | modifier le code ]

La 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

[modifier | modifier le code ]

defcheck_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

[modifier | modifier le code ]

Avec :

rib : le RIB complet sans espace à passer à la méthode.

defrib?(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_i36
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

[modifier | modifier le code ]

Cette 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.

selectSaisie.*
,97-mod(Banque*89+Guichet*15+Compte*3,97)CleRIB
from(selectsubstr(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
fromdual
)Saisie;

Vérification du RIB en SQL pour Oracle

[modifier | modifier le code ]

Cette vérification permet de vérifier un grand nombre de RIB, dans une table RIB_payment

CREATETABLE(rib_idNUMBER(10)
,rib_banqueVARCHAR2(12)
CONSTRAINTrib_banque_nn_paymentNOTNULLNOTNULL
,rib_guichetVARCHAR2(12)
CONSTRAINTrib_guichet_nn_paymentNOTNULL
,rib_compteVARCHAR2(20)
CONSTRAINTrib_compte_nn_paymentNOTNULL
,rib_cleVARCHAR2(3)
,rib_saisie_dateDATEDEFAULTSYSDATE
CONSTRAINTrib_saisie_date_nn_paymentNOTNULL
,person_idVARCHAR2(10)/*titulaire, personne morale ou physique*/
CONSTRAINTrib_person_id_nn_paymentNOTNULL
,CONSTRAINTrib_person_id_uk_payment
UNIQUE(person_id)
)

saisie au préalable, et en relation avec une table des personnes (personnes physiques ou personnes morales).

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

SELECTIBAN,
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
FROMCOMPTE

La requête contrôle le IBAN (on peut facilement le construire à partir du RIB).

Vérification du RIB en VBA

[modifier | modifier le code ]

Ce code fonctionne sous Excel, l'abréviation « VBE » étant la contraction de VBA pour Excel.

Code source en VBA ou VBE

Ces fonctions permettent de vérifier la validité d'un RIB

FunctionMod97(NumeroAsString)AsInteger
' Calcule le modulo 97 du numéro donné
DimNroAsString
DimaAsVariant,bAsVariant,cAsVariant,dAsVariant,eAsVariant,div97AsVariant
Nro=Numero
a=0
b=0
c=0
e=Right(Nro,6)
d=Mid(Nro,Len(Nro)-11,6)
SelectCaseLen(Nro)
Case13To20
c=CDbl(Mid(Nro,1,Len(Nro)-12))
Case21To28
c=CDbl(Mid(Nro,Len(Nro)-19,8))
IfLen(Nro)<>20Thenb=CDbl(Mid(Nro,1,Len(Nro)-20))
Case29To38
c=CDbl(Mid(Nro,Len(Nro)-19,8))
b=CDbl(Mid(Nro,Len(Nro)-27,8))
a=CDbl(Mid(Nro,1,Len(Nro)-28))
CaseElse
Mod97=0
ExitFunction
EndSelect
div97=Int((a*93+b*73+c*50+d*27+eMod97)/97)
Mod97=(a*93+b*73+c*50+d*27+eMod97)-div97*97
EndFunction
FunctionControleRib(cbanqueAsString,cguichetAsString,nocompteAsString,cleribAsString)
Consttransforme="12345678912345678923456789"
DimtabcompteAsString,lgAsLong,iAsLong,carAsString,cAsInteger,rib_intAsString
tabcompte=""
lg=Len(nocompte)
Iflg<>11Then
ControleRib=False
Else
Fori=1Tolg
car=Mid(nocompte,i,1)
IfNotIsNumeric(car)Then
c=asc(car)-(asc("A")-1)
tabcompte=tabcompte&Mid(transforme,c,1)
Else
tabcompte=tabcompte&car
EndIf
Nexti
rib_int=cbanque&cguichet&tabcompte&clerib
ControleRib=(Len(rib_int)>=21)And(Mod97(rib_int)=0)
EndIf
EndFunction

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 :

IfControleRib(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"
EndIf

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 | modifier le code ]

PrivateFunctiontextetochiffre(ByValnumeroAsString)AsInteger
IfIsNumeric(numero)=FalseThen
numero=Asc(numero)-55
EndIf
ReturnMath.Floor((numero+Math.Pow(2,(numero-10)/9))Mod10)
EndFunction
PrivateFunctionverifierrib(ByValplainribAsString)
DimribAsString=""
Fori=0Toplainrib.Count-1
rib=rib&textetochiffre(plainrib.Substring(i,1))
Next
DimbanknoteAsString=rib.Substring(0,5)
DimguichetAsString=rib.Substring(5,5)
DimcompteAsString=rib.Substring(10,11)
DimcleribAsString=rib.Substring(21,2)
DimresultAsInteger=(banknote*89+guichet*15+compte*3+clerib)Mod97
Ifresult=0Then
ReturnTrue
Else
ReturnFalse
EndIf
EndFunction

Conversion du RIB en IBAN

[modifier | modifier le code ]

Algorithme

[modifier | modifier le code ]

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#

[modifier | modifier le code ]

publicstaticstringGetIban(stringcodebanque,stringcodeGuichet,stringnumerocompte,stringcle)
{
conststringalphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
vartmp=(codebanque+codeGuichet+numerocompte+cle+"FR00").ToUpper();
foreach(varcintmp.Where(char.IsLetter))
{
tmp=tmp.Replace(c.ToString(CultureInfo.InvariantCulture),(alphabet.IndexOf(c)+10).ToString(CultureInfo.InvariantCulture));
}
varibanKey=(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

[modifier | modifier le code ]

publicstaticStringgetIBAN(Stringcodebanque,StringcodeGuichet,Stringnumerocompte,Stringcle){
Stringalphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Stringtmp=codebanque+codeGuichet+numerocompte+cle+"FR00";
tmp=tmp.toUpperCase();
for(charc:tmp.toCharArray()){
if(Character.isLetter(c)){
tmp=tmp.replaceAll(String.valueOf(c),String.valueOf(alphabet.indexOf(c)+10));
}
}
StringibanKey=
String.valueOf(newBigDecimal(98).subtract(newBigDecimal(tmp).remainder((newBigDecimal(97)))));
if(ibanKey.length()==1){
ibanKey="0"+ibanKey;
}
return"FR"+ibanKey+codebanque+codeGuichet+numerocompte+cle;
}

Conversion du RIB en IBAN en Perl

[modifier | modifier le code ]

usebigint;
subrib_to_iban{
my($rib)=@_;
my@letter=('0'..'9','A'..'Z');
my$iban="";
foreachmy$char(split(//,"${rib}FR00")){
my($index)=grep{$letter[$_]eq$char}(0..@letter-1);
$iban.=$index;
}
my$key=98-($iban%97);
returnsprintf("FR%.2d%s",$key,$rib);
}

Conversion du RIB en IBAN en PHP

[modifier | modifier le code ]

function 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

[modifier | modifier le code ]

Avec :

rib : le RIB complet sans espace à passer à la méthode.

defrib_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

[modifier | modifier le code ]

Avec :

rib : le RIB complet sans espace à passer à la méthode.

defrib_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 | modifier le code ]

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

Conversion du RIB en IBAN en SQL Server 2008 R2 (Microsoft)

[modifier | modifier le code ]

-- 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
CREATEFUNCTION[dbo].[SQL_F_BBAN_IBAN](@bbanvarchar(30),@bicvarchar(11))
RETURNSvarchar(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@bbanwkvarchar(60),@countrychar(2),@bbannbpint,@bbanpvarchar(9),@possmallint,@modint,@ismallint,@keyibanchar(2),@ibanvarchar(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)
whileisnumeric(@bbanwk+'e0')=0
BEGIN
set@pos=(selectpatindex('%[^0-9]%',@bbanwk))
set@bbanwk=(selectreplace(@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(@bbanpasint)%97
-- Put the result at the beginning of the next group			
set@bbanp=cast(@modasvarchar)+substring(@bbanwk,@pos,7)
set@i=@i+1
set@pos=@pos+7
END
-- IBAN key 2 characters
set@keyiban=right('00'+cast((98-@mod)asvarchar),2)
set@iban=@country+@keyiban+@bban
RETURN@iban
END
GO

Conversion du RIB en IBAN en SQL pour Oracle

[modifier | modifier le code ]

FUNCTIONSO_F_RIB_IBAN(pi_va_ribINVARCHAR2)RETURNVARCHAR2
IS
l_i_loopINTEGER;
l_va_returnVARCHAR2(40);
l_n_cleeINTEGER;
BEGIN
l_va_return:=UPPER(pi_va_rib)||'FR00';

-- Transformation de A-Z en 10-35
FORl_i_loopIN0..25LOOP
l_va_return:=REPLACE(l_va_return,CHR(65+l_i_loop),(10+l_i_loop));
ENDLOOP;

-- 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);
ENDSO_F_RIB_IBAN;

Conversion du RIB en IBAN en VBA

[modifier | modifier le code ]

Ce code fonctionne sous Excel, l'abréviation « VBE » étant la contraction de VBA pour Excel.

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

Conversion du RIB en IBAN en VB.NET

[modifier | modifier le code ]

PublicFunctionGetIBAN(ribAsString)AsString
rib=rib.Replace(" ","")
DimtmpIBANAsNewStringBuilder()
ForEachcAsCharIn(rib+"FR00").ToUpper()
DimvAsInteger=Asc(c)+If(c>="A"c,-Asc("A")+10,-Asc("0"))
tmpIBAN.Append(v)
Next
DimtmpIBANStringAsString=tmpIBAN.ToString()
DimchecksumAsInteger=0
ForEachcIntmpIBANString
checksum*=10
checksum+=Integer.Parse(c)
checksum=checksumMod97
Next
DimibanKeyAsString=(98-checksum).ToString()
Return"FR"+Right("0"&ibanKey,2)+rib
EndFunction

Conversion du RIB en IBAN en JavaScript

[modifier | modifier le code ]

functionGetIban(codeBanque,codeGuichet,numCompte,cleRib){
varalphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
vartmp="";
tmp=""+String(codeBanque)+String(codeGuichet)+String(numCompte)+String(cleRib)+"FR00";
tmp=tmp.toUpperCase();
tmp=tmp.split("");

for(vari=0;i<tmp.length;i++){
if(alphabet.indexOf(tmp[i])!=-1){
tmp[i]=String(alphabet.indexOf(tmp[i])+10);
}
}

tmp=tmp.join("");
varmoduloRemainder=parseInt(tmp%97,10);
varibanKey=(98-moduloRemainder).toString();
if(ibanKey.length==1){
ibanKey="0"+ibanKey;
}
return"FR"+ibanKey+codeBanque+codeGuichet+numCompte+cleRib;
};

Notes et références

[modifier | modifier le code ]

↑ « Prélèvements : le RIB cède la place aux normes SEPA », sur Le Monde.fr, 1^er août 2014 (consulté le 9 janvier 2020)
↑ Alexiane Turcant, « Tout savoir sur le RIB : Définition et Utilisation », sur selectra.info, 2023 (consulté le 19 août 2024)
↑ « RIB, IBAN et BIC : les petits noms de vos coordonnées bancaires », sur www.banque-france.fr, 2024 (consulté le 19 août 2024)
↑ « REGLEMENT (UE) No260/2012 DU PARLEMENT EUROPÉEN ET DU CONSEIL »
↑ « Article R351-5 du code monétaire », sur legifrance.gouv.fr

Articles connexes

[modifier | modifier le code ]

Clé RIB
ISO 13616, le code IBAN

icône décorative Portail de la finance

Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Basic_Bank_Account_Number&oldid=236170492 ».

Catégories cachées :