Pixels vers unités em
Convertissez une taille en pixels en em : 24 px dans un parent de 16 px font 1,5 em, prêts à coller sous la forme 1.5em. Texte et espacements suivent alors la police du parent et les réglages du lecteur. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Px
- 24
- Parent
- 16
- Em
- 1,5
- Em (CSS)
- 1.5em
- Rapport
- 1,5
- Précision
- 10
L'identité utilisée est entièrement déterministe : em est égal à px divisé par le parent. Les designers, ingénieurs frontend et auditeurs d'accessibilité utilisent cette conversion pour réécrire des échelles typographiques fixes en feuilles de style évolutives qui grandissent avec les réglages de police de l'utilisateur et le contexte des composants imbriqués. Le moteur n'emploie que de l'arithmétique finie, sans appels réseau, sans échantillonnage et sans raccourcis dépendants de la date.
Ce que vaut un em et comment on le calcule
Le pixel est une longueur fixe, alors que l'em dépend de la taille de police calculée de l'élément parent, et un em vaut exactement cette taille. Pour passer de l'un à l'autre, il suffit de diviser la valeur en pixels par la taille de police du parent. Ainsi, vingt-quatre pixels dans un parent de seize pixels donnent 1,5 em, et quatorze pixels dans le même parent donnent zéro virgule huit cent soixante-quinze em. Zéro pixel donne zéro em, ce qui sert à vider un jeton d'espacement. Le résultat est arrondi au nombre de décimales choisi, dix par défaut, et vous obtenez aussi la valeur prête à coller dans une feuille de style.
Quand l'utiliser et les erreurs à éviter
Les systèmes de design stockent souvent tailles et espacements en pixels, alors que le code final préfère l'em pour que les composants imbriqués s'adaptent à leur police locale. Les audits d'accessibilité convertissent aussi les marges fixes, afin que le zoom du texte et les réglages du lecteur agrandissent la mise en page dans les mêmes proportions. L'erreur la plus courante consiste à prendre la taille de la racine du document au lieu de celle du parent direct : c'est un autre calcul. Une taille de parent égale à zéro est refusée, car la division serait impossible. Cet outil ne fait que le sens pixels vers em.
Cas d’usage
Réécritures de feuilles de style et accessibilité
Réécrivez des tailles de police fixes en pixels en em pour que le zoom texte et la police utilisateur agrandissent la mise en page de façon proportionnelle.
Questions fréquentes
Combien coûte le convertisseur de pixels en em ?
Il est gratuit dans votre navigateur sur cette page.
Comment les pixels et l'em sont-ils liés ?
Un em équivaut à la taille de police du parent, donc 24px avec parent 16 donne 1.5em.
Que se passe-t-il si la taille de police du parent est zéro ?
Un parent nul rend em = px/parent indéfini (division par zéro).
Cet outil convertit-il l'em en pixels, ou en rem ?
Utilisez des outils dédiés pour la conversion inverse ou vers rem.
Pourquoi les résultats sont-ils arrondis à une précision ?
La précision par défaut est de 10 décimales ; vous pouvez fixer precision de 0 à 15.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/str/px-to-em \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"px":24,"parent":16}'const res = await fetch("https://api.kit.forhosting.com/str/px-to-em", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"px": 24,
"parent": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/px-to-em",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"px": 24,
"parent": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/px-to-em", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"px":24,"parent":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"px":24,"parent":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/px-to-em", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"px": 24,
"parent": 16
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.px_to_em",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_abs_value | 1000000000000000 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Ce convertisseur de pixels en em transforme une taille de police CSS donnée en pixels en unités em en utilisant la taille de police de l'élément parent comme base de référence. La typographie relative dépend de cette base : un em équivaut à la taille de police calculée du parent, de sorte que vingt-quatre pixels avec un parent de seize pixels valent un point cinq em, et quatorze pixels avec le même parent valent zéro point huit sept cinq em.
Ce que signifient pixels et em et ce que contient la réponse
Zéro est une valeur px valide et produit simplement zéro em, utile pour vider un jeton de taille ou affirmer un espacement vide. Une conversion CSS de pixels en em répond à une question de mise en page précise : étant donné une taille de police ou une longueur d'espacement en pixels et la taille de police de l'élément parent en pixels, quelle est la magnitude équivalente en em pour que le type, le padding et les tailles de composant restent proportionnels lorsque la cascade ou le zoom utilisateur changent. Les pixels sont des longueurs absolues indépendantes de l'appareil en CSS ; l'em est relatif à la taille de police calculée de l'élément parent, de sorte que la même valeur em s'adapte automatiquement lorsque la police du parent change. Ce calculateur accepte une valeur numérique px et une taille de police parent en pixels, puis renvoie le résultat em arrondi à une précision stable, une chaîne compacte em_css telle que 1.5em prête à coller dans une feuille de style, les entrées renvoyées en écho, un champ ratio égal au résultat em pour la clarté des tableaux, et un court rappel de formule. Il n'y a pas de chemin inverse em vers px sur cette page, ni de recherche de racine rem, ni de mathématiques de viewport, ni de simulation de media-query : le moteur divise px par parent dans la plage de magnitude prise en charge ou rejette l'entrée avec invalid_input. Les cas rejetés incluent px ou parent manquants, des nombres non finis, des magnitudes au-dessus du plafond documenté, et tout parent nul ou numériquement nul, car em égal à px sur parent diviserait par zéro. Si vous avez besoin d'une conversion bidirectionnelle, de rem, de pourcentages ou d'unités de viewport, utilisez les outils dédiés à ces domaines ; cette page répond uniquement de pixels en em avec une taille de police parent connue et une sortie numérique stable adaptée aux tableurs, tests unitaires et consommateurs d'API qui ne doivent pas inventer de facteurs à la main.
Comment px, parent et precision sont lus et comment les résultats restent reproductibles
La notation scientifique optionnelle sur les chaînes numériques est autorisée lorsqu'elle se parse en décimal fini ; les espaces intégrés, préfixes hex et jetons non numériques sont rejetés avec un message clair pour qu'une mauvaise cellule de tableur ne devienne pas une taille de type erronée. Le calcul est une seule division : em est égal à px divisé par parent. Les enseignants peuvent aussi utiliser le même contrat pour noter des devoirs demandant de convertir une échelle typographique en pixels en em pour des titres et un corps imbriqués. Les champs préférés sont px pour la magnitude en pixels et parent pour la taille de police du parent en pixels, avec les alias pixels, size, font_size, value et amount pour le champ pixels, et base, parent_px, parent_font_size, base_font_size et root pour le champ parent, afin que des clients hétérogènes partagent un seul contrat. Un parent nul échoue toujours avec invalid_input car la conversion relative en em est indéfinie sans taille de police parent non nulle. Un champ optionnel precision, avec les alias decimals et dp, choisit combien de décimales exposer pour px, parent, em et ratio, par défaut dix et plafonné à quinze pour que les goldens JSON restent stables entre runtimes. Associez l'exécution gratuite dans le navigateur de cette page à l'API tarifée lorsque vous avez besoin du même résultat mathématique dans un pipeline automatisé sans réimplémenter vous-même les mathématiques typographiques.
Où la conversion px vers em s'inscrit dans les design systems, le CSS et le logiciel
Les design systems stockent souvent les jetons d'espacement et de typographie en pixels pour les outils de design, tandis que le CSS de production préfère em pour les composants imbriqués qui doivent s'adapter à la taille de police locale ; un convertisseur déterministe unique évite la dérive de la calculatrice manuelle lorsqu'un designer, un ingénieur frontend ou un étudiant réécrit une feuille de style. Les audits d'accessibilité convertissent les paddings fixes en pixels et les tailles liées à la ligne en em pour que le zoom texte et les réglages de police de l'utilisateur agrandissent proportionnellement les cibles tactiles ; les modèles d'e-mail et les peaux héritées mélangent encore longueurs absolues et relatives et ont besoin d'une vérification rapide hors ligne avant une publication. Les développeurs appellent le même contrat depuis des scripts pour semer des vecteurs de test déterministes pour des générateurs de thèmes, normaliser des tailles saisies par l'utilisateur avant de dimensionner des démos, ou satisfaire des énoncés de défis de programmation qui exigent des ratios exacts plutôt qu'une estimation approximative. Les enseignants assignent des devoirs qui exigent une vérification rapide d'un corps à seize pixels et de titres à vingt-quatre sans faire confiance à des applications opaques qui basculent silencieusement vers rem ou omettent la base parent. Les outils produit utilisent la réécriture lorsqu'un apprenant ou un agent saisit vingt-quatre pixels et un parent de seize et que l'interface doit afficher un point cinq em à côté de l'écho en pixels. Sur cette page le travail s'exécute entièrement dans votre navigateur ; via l'API chaque consultation réussie coûte $0.002, la validation échouée n'est pas facturée et rien n'est stocké après le renvoi de la réponse. Cette séparation — exploration interactive gratuite et API identique tarifée — correspond au reste du catalogue KIT de niveau A et vous permet de passer d'une démo de classe à un pipeline automatisé sans changer le résultat mathématique. Gardez les outils rem ou viewport séparés lorsque la référence est la racine en cascade ou le viewport plutôt que la taille de police parent, et gardez ce convertisseur centré lorsque la question est strictement des pixels vers des unités em pour une typographie évolutive et accessible.
Cas d'intégration
Design tokens et échelles typographiques
Convertissez des jetons de type et d'espacement en pixels en em pour que les composants imbriqués s'adaptent à la taille de police du parent.
Fixtures CI déterministes
Générez des paires px→em reproductibles pour générateurs de thèmes, tests unitaires et pipelines de design systems.