Rogner les espaces de chaque ligne
Nettoyez les bords de chaque ligne d'un coup : trois lignes encombrées, dont une avec des tabulations, perdent 10 caractères superflus et donnent hello, world et foo bar, l'espace de foo bar étant conservé. Les lignes vides restent en place. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- hello world foo bar
- Entrée
- hello world foo bar
- Texte
- hello world foo bar
- Nombre de lignes
- 3
- Lignes
- hello, world, foo bar
Un rogneur d’espaces conscient des lignes transforme un collage multiligne désordonné en bords nets sans effondrer les mots à l’intérieur de chaque ligne. Saisissez toute chaîne non vide—journaux, extraits de code, dumps TSV ou prose copiée d’un document—et l’outil normalise les fins de ligne, découpe sur les sauts de ligne et applique un trim complet à chaque ligne afin que les espaces de tête, les tabulations de fin et le bruit d’indentation mixte disparaissent tandis que l’espacement intérieur reste intact. Éditeurs, scripts d’assurance qualité, correcteurs de devoirs et préprocesseurs ETL ont besoin de la même règle par ligne sans ouvrir un rechercher-remplacer d’IDE complet.
Ce que signifie le trim par ligne et pourquoi il diffère de String.trim
La plupart des langages offrent un seul trim qui n’enlève les espaces qu’au début et à la fin de toute la chaîne. Cela laisse intactes les lignes médianes indentées, ce qui est exactement le problème lorsque vous collez un bloc de lignes de journal, un échantillon de code avec des espaces finaux accidentels ou un export de tableur multi-lignes où chaque ligne a des cellules remplies.
Cet outil rogne chaque ligne indépendamment : après normalisation des sauts Windows CRLF et CR hérités en une forme LF unique, le texte est découpé sur LF, chaque segment passe par un trim d’espaces Unicode complet et les segments sont réunis avec LF. Les espaces intérieurs entre les mots restent ; seuls les bords de chaque ligne sont nettoyés.
Les lignes vides entre le contenu deviennent des chaînes vides après le trim, de sorte que la structure qui utilisait des séparateurs blancs reste visible comme lignes vides plutôt que de disparaître. Les lignes vides en tête et en queue du collage d’origine restent présentes comme lignes vides après le découpage, car l’algorithme ne supprime pas les lignes—il ne fait que les rogner.
La conception correspond aux commandes d’éditeur courantes telles que « rogner les espaces de fin » appliquées à une sélection, tout en nettoyant aussi le remplissage de tête qui apparaît souvent en copiant depuis des listes indentées ou des interfaces de chat.
Conseils pratiques, limites et recherches associées
Utilisez cette capacité lorsque l’intention de recherche est de rogner les espaces des lignes, d’enlever les marges de début et de fin multiligne ou de nettoyer un collage indenté en ligne. Gardez l’indentation intentionnelle à l’esprit seulement si vous avez besoin d’espaces de tête pour la mise en page du code—cet outil les enlève ; si vous voulez seulement un nettoyage de fin en préservant l’indentation, il faut une autre politique ou un pré-passage.
La source HTML et Markdown rogne encore chaque ligne brute de la chaîne envoyée ; retirez d’abord les balises si vous vous souciez du texte rendu plutôt que du balisage. Cette page n’est pas un simple String.trim de document entier, pas un suppresseur de lignes vides, pas un effondreur d’espaces qui transforme les doubles espaces en un, pas un nettoyeur de cellules CSV conscient des délimiteurs, et pas un réécrivain par IA.
En enseignant aux étudiants ou en formant des relecteurs, montrez le même échantillon avant et après pour qu’ils voient que seuls les bords de ligne changent et que l’espacement interne des mots est laissé intact.
Cas d’usage
Nettoyer collages de journal et console pour tickets
Les développeurs collent des journaux multilignes avec des espaces de tête accidentels et des tabs de fin ; l’outil renvoie des lignes alignées prêtes pour les trackers de bugs et les diffs.
Normaliser dumps de devoirs et dissertations
Enseignants et scripts LMS retirent le remplissage des bords de chaque ligne soumise avant que les pipelines de comptage de mots ou de plagiat voient le texte.
Questions fréquentes
Cela enlève-t-il les espaces entre les mots ?
Non. Seuls les espaces de début et de fin de chaque ligne sont retirés. Les espaces et tabs intérieurs d’une ligne sont préservés.
Que se passe-t-il avec une entrée vide ?
Fournissez une chaîne non vide avec au moins un caractère non espace.
Les lignes vides sont-elles supprimées ?
Non. Les lignes vides restent des lignes vides après le trim. L’outil ne supprime ni ne fusionne les lignes ; il ne rogne que les bords de chacune.
Comment sont gérées les fins de ligne Windows ?
CRLF et le CR isolé sont normalisés en LF avant le découpage pour que le même collage produise le même résultat sur chaque plateforme.
Le rogneur d’espaces par ligne est-il gratuit ?
L’outil du navigateur est gratuit et s’exécute en local.
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/trim-lines \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":" hello \n\tworld\t\n foo bar "}'const res = await fetch("https://api.kit.forhosting.com/str/trim-lines", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": " hello \n\tworld\t\n foo bar "
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/trim-lines",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": " hello \n\tworld\t\n foo bar "
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/trim-lines", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":" hello \\n\\tworld\\t\\n foo bar "}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":" hello \n\tworld\t\n foo bar "}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/trim-lines", 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
{
"text": " hello \n\tworld\t\n foo bar "
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.trim_lines",
"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_chars | 100000 |
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
Une entrée vide ou uniquement composée d’espaces est rejetée avec une erreur invalid_input claire pour que l’automatisation ne traite jamais un collage blanc comme un nettoyage réussi. Le chemin est une logique de chaînes pure et déterministe—sans réseau, sans graines aléatoires, sans dépendance d’horloge—de sorte que l’exécuteur gratuit du navigateur et l’API prépayée renvoient le même JSON à chaque appel.
Ce que signifie le trim par ligne et pourquoi il diffère de String.trim
Une entrée entière vide ou uniquement d’espaces est une erreur dure : il n’y a pas de document nettoyé significatif à renvoyer, et les clients doivent le traiter comme invalid_input plutôt qu’un succès à zéro ligne.
Comment appeler l’API et ce que contient la réponse
Préférez envoyer le corps multiligne brut plutôt que de pré-effondrer les sauts de ligne lorsque vous voulez une vraie sémantique par ligne ; tout effondrer en une seule ligne ne rognerait que les bords extérieurs d’un unique segment. Envoyez un corps JSON avec un champ string obligatoire text (alias input, value, string, s, content et body). La valeur doit être une chaîne non vide après le trim global des espaces et ne doit pas dépasser cent mille caractères afin qu’une seule requête n’épuise pas la mémoire du Worker ou du navigateur sur d’énormes collages. En cas de succès la réponse renvoie input comme la chaîne d’origine envoyée, text comme le résultat entièrement rogné par ligne joint avec LF, line_count comme le nombre de lignes après découpage (y compris les vides), lines comme un tableau ordonné des chaînes de ligne rognées, chars_before et chars_after comme les longueurs des chaînes d’origine et nettoyée, chars_removed comme le nombre total de caractères retirés par le trim, et message comme un court résumé en anglais qui rapporte le nombre de lignes et les caractères retirés. Une validation échouée—text manquant, valeur non string, charge trop grande ou contenu vide après le trim global—renvoie invalid_input et n’est jamais facturée. Le tarif est un $0.002 forfaitaire par requête réussie avec unité item et prix unitaire marginal nul. À l’intégration, assertez sur text ou lines pour le contenu nettoyé, comparez éventuellement chars_removed pour des contrôles de régression, et traitez invalid_input comme un bug client sur les envois de formulaire vides plutôt qu’un événement de facturation.
Conseils pratiques, limites et recherches associées
Les contrôles aller-retour pour les tests sont simples : fournissez deux lignes remplies et attendez ces mots alignés à gauche sans espaces de fin ; fournissez une troisième ligne indentée par tab et confirmez que le tab a disparu tandis que les doubles espaces intérieurs d’une phrase restent ; envoyez délibérément une chaîne vide ou uniquement des espaces pour confirmer invalid_input et le message qui demande une chaîne non vide. Préférez data.clean_csv lorsque la charge est du CSV tabulaire avec corrections d’encodage ; préférez str.paragraph_count lorsque vous avez besoin de totaux de paragraphes par lignes vides ; préférez cette capacité lorsque des humains ont déjà séparé les lignes et que vous n’avez besoin que de bords propres sur chacune. Les tâches échouées qui renvoient invalid_input ne consomment pas le solde prépayé, ce qui maintient bon marché la validation de formulaires et les tests négatifs de CI.
Cas d'intégration
Tests unitaires pour préprocesseurs de texte
Générez des fixtures multilignes remplies de référence et des rejets d’entrée vide pour éditeurs, étapes ETL et pipelines markdown.