Convertir des octets en mégaoctets est une opération d’une ligne dans les trois langages, mais le résultat dépend d’un choix que la plupart des exemples en ligne ne documentent pas : divise-t-on par 1 000 000 ou par 1 048 576 ? Ce n’est pas la même valeur, et afficher « Mo » sans préciser la convention expose à des incohérences entre ce qu’un système de fichiers rapporte et ce qu’un navigateur ou une API affiche.
Mo décimal vs Mio binaire : choisir la bonne base avant d’écrire le moindre code
Un mégaoctet décimal (MB selon la notation SI) vaut exactement 106 octets, soit 1 000 000 octets. Un mébioctet (MiB selon la notation IEC) vaut 220 octets, soit 1 048 576 octets. La différence représente environ 4,9 % – négligeable pour un affichage approximatif, mais significative dès que l’on compare des tailles entre systèmes.
Le contexte détermine l’unité correcte :
- Taille d’un fichier sur disque : les systèmes de fichiers Linux et macOS rapportent en base 10 dans leurs outils modernes (
ls -lh, Finder). Diviser par 1 000 000 colle à l’affichage natif. - Capacité de stockage annoncée : les fabricants de disques durs utilisent la base décimale. Un SSD de 500 GB contient 500 000 000 000 octets, pas 536 870 912 000.
- Mémoire vive ou cache CPU : les systèmes d’exploitation rapportent la RAM en base 2. Windows Task Manager,
/proc/meminfosous Linux : tout est en KiB, MiB, GiB. Utiliser la base 10 ici donne un résultat incorrect.
Nommer explicitement l’unité dans l’interface – « Mo (1 000 000 octets) » ou « Mio (1 048 576 octets) » – évite la confusion. Afficher simplement « Mo » sans précision est une décision implicite qui peut induire l’utilisateur en erreur.
Conversion octet en Mo en Python
Python gère les entiers arbitrairement grands nativement, sans limite de représentation exacte. C’est l’environnement le plus propre pour cette opération.
def octets_en_mo(octets, binaire=False):
diviseur = 1_048_576 if binaire else 1_000_000
return octets / diviseur
# Exemple
taille = 52_428_800 # octets
print(f"{octets_en_mo(taille):.2f} Mo") # 52.43 Mo (décimal)
print(f"{octets_en_mo(taille, binaire=True):.2f} Mio") # 50.00 Mio
Le paramètre binaire rend la convention explicite dans le code lui-même, pas seulement dans un commentaire. Pour un rendu lisible sur plusieurs ordres de grandeur (Ko, Mo, Go), la bibliothèque standard math suffit pour calculer l’exposant dynamiquement.

Conversion octet en Mo en PHP
PHP utilise des flottants 64 bits (IEEE 754 double précision) pour ses opérations arithmétiques. Sur les architectures 64 bits modernes, les entiers PHP vont jusqu’à 9 223 372 036 854 775 807, ce qui couvre largement les tailles de fichiers courantes.
function octets_en_mo(int $octets, bool $binaire = false): float {
$diviseur = $binaire ? 1048576 : 1000000;
return $octets / $diviseur;
}
// Affichage avec deux décimales
$taille = 52428800;
echo number_format(octets_en_mo($taille), 2) . " Mo\n"; // 52,43 Mo
echo number_format(octets_en_mo($taille, true), 2) . " Mio\n"; // 50,00 Mio
Typer le paramètre $octets en int protège contre une chaîne passée depuis un formulaire ou une API JSON. PHP cast silencieusement une chaîne « 52428800 » en entier dans ce contexte, mais le typage strict (declare(strict_types=1)) lève une erreur si le type ne correspond pas.
Conversion octet en Mo en JavaScript et le problème BigInt
JavaScript est le seul des trois langages où la conversion d’octets en Mo peut produire un résultat silencieusement faux pour les grandes valeurs.
Le type Number représente exactement tous les entiers jusqu’à Number.MAX_SAFE_INTEGER, soit 253 – 1 (9 007 199 254 740 991). Au-delà de cette limite, deux entiers distincts peuvent être représentés par la même valeur Number. Pour une taille de fichier de quelques gigaoctets, le problème ne se pose pas. Pour des offsets dans un fichier vidéo de plusieurs téraoctets ou des ID de base de données très grands, il devient réel.
// Conversion simple (sûre pour les tailles < ~9 Po)
function octetsEnMo(octets, binaire = false) {
const diviseur = binaire ? 1_048_576 : 1_000_000;
return octets / diviseur;
}
// Conversion avec BigInt pour les très grandes valeurs
function octetsEnMoBigInt(octets, binaire = false) {
const diviseur = binaire ? 1_048_576n : 1_000_000n;
const entier = BigInt(octets); // octets doit être une chaîne ou un entier sûr
const resultat = entier / diviseur;
return Number(resultat); // perte de précision sur les décimales, acceptable ici
}
console.log(octetsEnMo(52_428_800)); // 52.4288
console.log(octetsEnMo(52_428_800, true)); // 50
Le point critique documenté par MDN : convertir en BigInt un Number déjà arrondi ne restaure pas la valeur d'origine. Si la taille arrive depuis une API JSON comme un entier JSON de grande taille, le parser JavaScript l'a déjà convertie en Number avant que le code ne la touche. La seule solution est de la recevoir comme chaîne de caractères (via une API qui retourne les grands entiers en string) et de la passer directement à BigInt("valeur").
Afficher l'unité dynamiquement en JavaScript
Une fonction utilitaire courante adapte l'unité à la magnitude de la valeur. L'implémentation propre garde la convention (décimale ou binaire) cohérente sur tous les paliers :
function formatTaille(octets, binaire = false) {
const unites = binaire
? ['o', 'Kio', 'Mio', 'Gio', 'Tio']
: ['o', 'Ko', 'Mo', 'Go', 'To'];
const base = binaire ? 1024 : 1000;
let i = 0;
let valeur = octets;
while (valeur >= base && i < unites.length - 1) {
valeur /= base;
i++;
}
return `${valeur.toFixed(2)} ${unites[i]}`;
}
console.log(formatTaille(1_500_000)); // "1.50 Mo"
console.log(formatTaille(1_500_000, true)); // "1.43 Mio"
Tableau récapitulatif des formules selon le contexte
| Contexte | Unité correcte | Diviseur |
|---|---|---|
| Taille de fichier (affichage) | Mo (décimal) | 1 000 000 |
| Capacité disque dur / SSD | Mo (décimal) | 1 000 000 |
| RAM, cache, mémoire vive | Mio (binaire) | 1 048 576 |
| Interopérabilité avec l'OS Linux | Mio (binaire) | 1 048 576 |
Les trois langages effectuent la même division ; ce qui diffère, c'est la gestion des cas limites. Python n'a pas de plafond sur les entiers. PHP est sûr jusqu'aux tailles de fichiers atteignables sur les systèmes actuels. JavaScript exige une attention particulière dès que la valeur d'entrée dépasse Number.MAX_SAFE_INTEGER ou provient d'une source externe non typée.
