Quebrar texto na largura da linha
Defina uma largura de 40 e uma frase longa volta em 3 linhas, nenhuma com mais de 40 caracteres e sem nenhuma palavra cortada ao meio. Suas próprias quebras de linha ficam onde estão. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Largura
- 40
- Contagem de linhas
- 3
- Palavra mais longa
- 6
É o clássico algoritmo de quebra de linha feito da maneira certa: guloso, determinístico, seguro para as palavras e honesto o bastante para recusar o trabalho quando uma única palavra é mais longa que a largura pedida. Você envia uma string e um inteiro, e recebe o texto quebrado, as linhas individuais e algumas contagens úteis.
Por que a quebra que respeita palavras importa
A maioria das superfícies de exibição impõe um limite rígido de colunas: um terminal com oitenta colunas, um e-mail de texto simples com setenta e duas, um bloco de comentários de código com cem, uma fatura impressa com quarenta. Refluir texto à mão é tedioso e sujeito a erros, e a abordagem ingênua — fatiar a string a cada N caracteres — destrói a legibilidade porque corta palavras ao meio.
A capacidade de quebrar texto em uma largura de linha faz o trabalho corretamente com um algoritmo guloso: percorre as palavras em ordem, adiciona cada uma à linha atual enquanto ela couber e abre uma nova linha quando a próxima palavra transbordaria. As palavras nunca são partidas, a hifenização nunca é inventada e o resultado é estável: a mesma entrada e a mesma largura sempre produzem uma saída idêntica byte a byte, o que a torna segura em testes, em documentos gerados e em qualquer pipeline que compare texto.
As quebras de linha existentes são preservadas e cada linha de origem é quebrada de forma independente, de modo que parágrafos pré-formatados mantêm sua estrutura.
Como o algoritmo se comporta nos limites
O contrato é rigoroso onde o rigor protege você. A largura deve ser um inteiro positivo e pelo menos tão longa quanto a palavra mais longa do texto. Essa recusa é deliberada: um documento quebrado que secretamente excede seu orçamento de colunas quebra layouts a jusante, e você quer detectar isso na origem.
Sequências de espaços colapsam em espaços simples, linhas em branco sobrevivem como linhas em branco e a saída informa a largura usada, o número de linhas produzidas e o comprimento da palavra mais longa encontrada, para que você registre exatamente o que aconteceu. O algoritmo mede o comprimento em caracteres como o JavaScript os conta, que é a unidade certa para contextos de terminal e de código de largura fixa.
Casos de uso
Quebrar mensagens de commit e changelogs
Reflua os corpos em prosa para o limite convencional de 72 colunas antes de gravá-los em um repositório ou arquivo de versão.
Formatar e-mails de texto simples
Mantenha os e-mails gerados dentro do clássico envelope de 78 colunas para que renderizem de forma limpa em qualquer cliente de e-mail.
Diagramar saída de terminal e CLI
Quebre a ajuda e as descrições na largura detectada do terminal sem nunca partir uma flag ou uma URL no meio da palavra.
Perguntas frequentes
Quanto custa?
Também é grátis no seu navegador nesta página — o mesmo código roda nos dois lugares.
O que acontece se uma palavra for mais longa que a largura?
A capacidade nunca parte uma palavra para fazê-la caber.
As quebras de linha existentes são preservadas?
Sim. A entrada é primeiro dividida em linhas e cada linha é quebrada de forma independente, de modo que a estrutura dos parágrafos sobrevive.
Ela hifeniza palavras longas?
Não. A hifenização nunca é inventada; as palavras são mantidas inteiras e a linha simplesmente quebra mais cedo.
A saída é determinística?
Sim. O algoritmo guloso não tem aleatoriedade, relógio ou dependência de localidade, então entradas idênticas sempre geram saídas idênticas.
Quanto texto posso enviar?
Divida documentos maiores nos limites de parágrafo antes de enviar.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/text/wrap-width \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.","width":40}'const res = await fetch("https://api.kit.forhosting.com/text/wrap-width", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.",
"width": 40
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/wrap-width",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.",
"width": 40
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/wrap-width", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.","width":40}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.","width":40}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/wrap-width", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"text": "The quick brown fox jumps over the lazy dog while the sun rises slowly over the quiet hills.",
"width": 40
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.wrap_width",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_mb | 1 |
max_chars | 500000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
A API de quebra de texto recebe qualquer texto simples e uma largura máxima de linha, e devolve o texto refluído em linhas que nunca excedem essa largura e nunca dividem uma palavra. Sem adivinhação, sem hifenização oculta, sem surpresas entre ambientes — o mesmo código roda de graça no seu navegador e por trás da API paga.
Como o algoritmo se comporta nos limites
Se uma única palavra — digamos, uma URL, um número de série ou um composto longo — exceder a largura, a capacidade recusa com um erro invalid_input claro que nomeia a palavra infratora e seu comprimento, em vez de emitir silenciosamente uma linha que viola o seu limite.
Onde ela se encaixa em um pipeline
As equipes a chamam onde quer que texto de largura fixa seja gerado: ao formatar notas de versão para um arquivo de changelog, ao quebrar corpos de mensagens de commit nas convencionais setenta e duas colunas, ao preparar modelos de e-mail de texto simples, ao diagramar a ajuda de um terminal ou ao encaixar descrições no orçamento de colunas de um PDF ou fatura gerados. E como a saída também inclui as linhas como um array, as etapas seguintes podem uni-las com seu próprio separador, numerá-las ou comparar duas quebras sem repartir o texto. Por ser uma capacidade de análise pura, sem rede e sem modelo, é rápida, barata a US$ 0,002 por requisição e determinística o bastante para fazer parte de uma suíte de testes. As entradas são limitadas a 500000 caracteres por requisição, o que cobre confortavelmente qualquer documento realista; corpus maiores devem ser divididos em limites naturais, como parágrafos, antes do envio.