Basic Bank Account Number

 Pour les articles homonymes, voir RIB.

Le BBAN est une subdivision locale de l'IBAN délivré par la banque et que l'on remet à un débiteur ou un créancier dans le but d'opérer des virements bancaires ou des prélèvements bancaires à partir d'un compte courant. En France, on trouve souvent un RIB indiquant le BBAN à la fin des carnets de chèques ou en tête du relevé de compte.

On utilise parfois, en France, les appellations :

• RIB pour relevé d’identité bancaire en France
• RICE pour relevé d’identité Caisse d’épargne
• RIP, à l'usage désuet, et qui mentionnait les références d'un compte courant postal ouvert auprès des services financiers de La Poste ; les RIB sont désormais l'usage à La Banque postale.

Le terme RIB

En France

La notion de RIB a été officiellement abolie avec le passage au format SEPA.

Cependant, dans la pratique, le terme RIB est encore largement utilisé en France. Le document RIB existe toujours, et a simplement été mis à jour pour inclure le BIC et l’IBAN au format SEPA. 

En France, avant le passage au format SEPA, le terme RIB désignait officiellement un document présentant le numéro de compte bancaire au format français. Il était parfois aussi utilisé pour désigner simplement le numéro de compte bancaire au format français. 

Hors de France

Le terme RIB n’existe pas hors de France. Il n’existe pas de document équivalent dans tous les pays de la zone SEPA, et le terme est inconnu même dans la plupart des autres pays francophones.

Le SEPA ne définit pas de document ou de format spécifique permettant au propriétaire d’un compte de justifier de son BIC et de son IBAN.

Dans la plupart des pays de zone SEPA, la fourniture d'une pièce justificative pour preuve du BIC et de l'IBAN est soit inutile, soit basée sur d'autres documents. Par exemple, le numéro de compte (et progressivement les BIC et IBAN depuis le lancement de SEPA), apparaissent parfois sur les cartes bancaires de débit. C’est le cas notamment en Belgique et en Allemagne.

L’absence de document similaire au RIB dans la plupart les pays de la zone SEPA pose des problèmes pratiques pour les sociétés françaises. Ces sociétés françaises acceptent officiellement les coordonnées bancaires d’un client situé dans la zone SEPA (par exemple pour un prélèvement automatique SEPA), mais ignorent que le client ne peut fournir de document RIB. 

Composition

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

• 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)

Clef RIB

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$, etc.) en laissant un saut entre R et S.

Calcul de la Clef RIB en Java

	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

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

Algorithme

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}}$

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}}$

Vérification du RIB en C#

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

Code source en C#

 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
            // Algo ici : http://fr.wikipedia.org/wiki/Clé_RIB#Algorithme_de_calcul_qui_fonctionne_avec_des_entiers_32_bits
 
            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="c">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");
        }

Algorithme de clé RIB | developpez.com

 

Vérification du RIB en Java

import java.math.BigDecimal;

public class Validation{
    public boolean checkRib(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);
        }

        return new BigDecimal(extendedRib.toString()).remainder(new BigDecimal(97)).intValue() == 0;
    }
}

Vérification du RIB en Perl

Avec :

• $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

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

def check_bic(bic):
    replacement_table = {
            'AJaj': '1',
            'BKSbks': '2',
            'CLTclt': '3',
            'DMUdmu': '4',
            'ENVenv': '5',
            'FOWfow': '6',
            'GPXgpx': '7',
            'HQYhqy': '8',
            'IRZirz': '9',
            }
    if len(bic) != 23:
        return False
    for i in range(len(bic)):
        char = bic[i]
        for pattern in replacement_table.keys():
            if char in pattern:
                bic = bic.replace(char, replacement_table[pattern])
    bankcode = int(bic[:5])
    counter = int(bic[5:10])
    account = int(bic[10:21])
    key = int(bic[21:])
    return (bankcode*89 + counter*15 + account*3 + key) % 97 == 0

Vérification du RIB en Ruby

Avec :

• 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

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.

  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

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

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

 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

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

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

    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

Algorithme

1. Créer un IBAN temporaire, composé du code du pays : FR pour la France, suivi de " 00 " et du " code RIB "
2. Déplacer les 4 premiers caractères de l’IBAN vers la droite du numéro.
3. Convertir les lettres en chiffres, selon le principe "A" vaut "10" ... "Z" vaut "35".
4. 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#

 public static String GetIban(string codebanque, string codeGuichet, string numerocompte, string cle)
       {
           String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
           String tmp = codebanque + codeGuichet + numerocompte + cle + "FR00";
           tmp = tmp.ToUpper();
           foreach (char c in tmp.ToCharArray())
           {
               if (char.IsLetter(c))
               {
                   tmp = tmp.Replace(c.ToString(), (alphabet.IndexOf(c) + 10).ToString());
               }
           }
           var moduloRemainder = System.Numerics.BigInteger.Parse(tmp) % 97;
           String ibanKey = (98 - moduloRemainder).ToString();
           if (ibanKey.Length == 1)
           {
               ibanKey = "0" + ibanKey;
           }
           return "FR" + ibanKey + codebanque + codeGuichet + numerocompte + cle;
       }

Conversion du RIB en IBAN en Java

public 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

use 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

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

Avec :

• 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

Avec :

• 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

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

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

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

FUNCTION 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

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 !

Conversion du RIB en IBAN en VB.NET

Public 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

 1 function GetIban(codeBanque, codeGuichet, numCompte, cleRib) {
 2         var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 3         var tmp = "";
 4         tmp = "" + String(codeBanque) + String(codeGuichet) + String(numCompte) + String(cleRib) + "FR00";
 5         tmp = tmp.toUpperCase();
 6         tmp = tmp.split(""); 
 7         
 8         for (var i = 0; i < tmp.length; i++) {
 9             if (alphabet.indexOf(tmp[i]) != -1) {
10                 tmp[i] = String(alphabet.indexOf(tmp[i]) + 10);
11             }
12         }
13 
14         tmp = tmp.join("");
15         var moduloRemainder = parseInt(modulo(tmp, 97));
16         var ibanKey = (98 - moduloRemainder).toString();
17         if (ibanKey.length == 1) {
18             ibanKey = "0" + ibanKey;
19         }
20         return "FR" + ibanKey + codeBanque + codeGuichet + numCompte + cleRib;
21     };

Articles connexes

• Clé RIB
• ISO 13616, le code IBAN