Como Contar Palavras, Caracteres e Linhas em um Texto (Online e por Código)

Contar palavras parece trivial até você se deparar com os casos extremos: uma palavra com hífen conta como uma ou duas? E URLs? O que fazer com texto em vários idiomas? Este guia cobre métodos de contagem precisos para cada ambiente.

No navegador

Cole o texto no contador de palavras e obtenha instantaneamente a contagem de palavras, caracteres, caracteres sem espaços, frases, parágrafos e tempo estimado de leitura. Atualiza conforme você digita — útil quando você está escrevendo dentro de um limite (threads do Twitter, inscrições, submissões de artigos).

O que conta como palavra?

A definição padrão: uma sequência de caracteres não-espaço separada por espaço em branco. Sob essa definição:

• hello world → 2 palavras
• well-known → 1 palavra (com hífen)
• C++ → 1 palavra
• https://example.com/path?q=1 → 1 palavra
• "quoted text" → 2 palavras (pontuação fica junto às palavras adjacentes)

Para a maioria dos propósitos, isso é suficiente. Se você precisar excluir URLs, remova-os antes de contar.

JavaScript

Contagem básica de palavras:

function wordCount(text) {
    return text.trim().split(/\s+/).filter(Boolean).length;
}

console.log(wordCount("Hello world"));        // 2
console.log(wordCount("  spaces   matter  ")); // 2
console.log(wordCount(""));                    // 0

O filter(Boolean) remove strings vazias resultantes de múltiplos espaços consecutivos ou espaços em branco no início/fim.

Contagem de caracteres:

function textStats(text) {
    return {
        characters: text.length,
        charactersNoSpaces: text.replace(/\s/g, '').length,
        words: text.trim() === '' ? 0 : text.trim().split(/\s+/).length,
        sentences: (text.match(/[.!?]+/g) || []).length,
        paragraphs: text.trim() === '' ? 0 : text.trim().split(/\n\s*\n/).length,
        readingTimeMinutes: Math.ceil(text.trim().split(/\s+/).length / 200),
    };
}

const stats = textStats("Hello world. This is a test.\n\nSecond paragraph.");
console.log(stats);
// {
//   characters: 48,
//   charactersNoSpaces: 40,
//   words: 9,
//   sentences: 2,
//   paragraphs: 2,
//   readingTimeMinutes: 1
// }

O tempo de leitura usa 200 palavras por minuto (a média citada para leitura de texto online; 250 ppm para livros).

Mapa de frequência (quais palavras aparecem mais):

function wordFrequency(text) {
    const words = text.toLowerCase().match(/\b[a-z']+\b/g) || [];
    return words.reduce((freq, word) => {
        freq[word] = (freq[word] || 0) + 1;
        return freq;
    }, {});
}

const freq = wordFrequency("the cat sat on the mat the cat");
const sorted = Object.entries(freq).sort((a, b) => b[1] - a[1]);
console.log(sorted);
// [['the', 3], ['cat', 2], ['sat', 1], ['on', 1], ['mat', 1]]

Python

Contagem de palavras e caracteres:

def text_stats(text: str) -> dict:
    words = text.split()
    sentences = len([s for s in text.replace('!', '.').replace('?', '.').split('.') if s.strip()])
    paragraphs = len([p for p in text.strip().split('\n\n') if p.strip()])

    return {
        'characters': len(text),
        'characters_no_spaces': len(text.replace(' ', '')),
        'words': len(words),
        'sentences': sentences,
        'paragraphs': paragraphs,
        'reading_time_minutes': max(1, len(words) // 200),
    }

sample = "Hello world. This is a test.\n\nSecond paragraph here."
print(text_stats(sample))

Contar palavras em um arquivo:

def count_words_in_file(filepath: str) -> dict:
    with open(filepath, encoding='utf-8') as f:
        text = f.read()
    return text_stats(text)

print(count_words_in_file('essay.txt'))

Frequência de palavras:

from collections import Counter
import re

def word_frequency(text: str, top_n: int = 10) -> list[tuple[str, int]]:
    words = re.findall(r"\b[a-z']+\b", text.lower())
    return Counter(words).most_common(top_n)

sample = "the cat sat on the mat the cat"
print(word_frequency(sample))
# [('the', 3), ('cat', 2), ('sat', 1), ('on', 1), ('mat', 1)]

Linha de comando

Linux/macOS:

# Contar palavras
wc -w file.txt

# Contar linhas, palavras, caracteres
wc file.txt
# saída: linhas palavras chars nome_do_arquivo

# Contar palavras em uma string
echo "hello world" | wc -w
# 2

# Contar palavras em múltiplos arquivos, com totais
wc -w *.txt

Contar palavras únicas (tamanho do vocabulário):

cat file.txt | tr '[:upper:]' '[:lower:]' | tr -cs '[:alpha:]' '\n' | sort | uniq -c | sort -rn | head -20

Esse pipeline: minúsculas → uma palavra por linha → ordenar → contar únicas → ordenar por contagem.

One-liner Python:

python3 -c "import sys; text=open(sys.argv[1]).read(); print(len(text.split()))" file.txt

Windows PowerShell:

(Get-Content file.txt -Raw).Split() | Where-Object { $_ } | Measure-Object | Select-Object -ExpandProperty Count

Limites de caracteres comuns por plataforma

Para títulos e descrições SEO, a contagem de caracteres importa mais que a de palavras porque o Google trunca com base na largura em pixels (aproximadamente 580 px para títulos).

Excluindo conteúdo específico antes de contar

Contar palavras ignorando URLs:

function countWordsNoUrls(text) {
    const noUrls = text.replace(/https?:\/\/\S+/g, '');
    return noUrls.trim().split(/\s+/).filter(Boolean).length;
}

Contar palavras ignorando blocos de código (Markdown):

import re

def count_words_no_code(markdown: str) -> int:
    # Remover blocos de código delimitados
    no_code = re.sub(r'```[\s\S]*?```', '', markdown)
    # Remover código inline
    no_code = re.sub(r'`[^`]+`', '', no_code)
    return len(no_code.split())

Pontos principais

• Contagem de palavras: text.split() em Python, text.trim().split(/\s+/).filter(Boolean) em JavaScript.
• Contagem de caracteres: len(text) em Python, text.length em JavaScript.
• Linha de comando: wc -w file.txt no Linux/macOS.
• Tempo de leitura: palavras ÷ 200 (arredondado para cima).
• Para metadados SEO, conte caracteres não palavras — o Google trunca por largura em pixels, não por contagem de palavras.