R Academy · Aula

Preenchimento e alinhamento de strings

Use formatC() e format() para saída de texto com largura fixa e alinhada.

Preenchimento e alinhamento de strings é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Por que o preenchimento de cadeias é importante

A saída de largura fixa é essencial para tabelas de texto simples, arquivos de registro e relatórios. O R fornece formatC() e format() para preencher valores até uma largura fixa, garantindo que as colunas fiquem corretamente alinhadas em exibições monoespaçadas.

# Unformatted: columns misalign
cat('Alice 85\n')
cat('Bob 9200\n')
# Padded: columns align
cat(formatC('Alice', width = 10), formatC(85,   width = 6), '\n')
cat(formatC('Bob',   width = 10), formatC(9200, width = 6), '\n')

formatC() — Preenchimento alinhado à direita

formatC(x, width = n) preenche o valor até que ele tenha pelo menos n caracteres de largura, alinhando-o à direita por padrão. Espaços são adicionados à esquerda. Isso funciona tanto para números quanto para cadeias de caracteres.

formatC('hi',   width = 10)
formatC(42,     width = 10)
formatC(3.14,   width = 10)

Alinhamento à esquerda de formatC() com flag

O argumento flag = '-' muda para o alinhamento à esquerda, preenchendo o lado direito com espaços. Isso é ideal para rótulos de texto em colunas de tabelas quando você quer que os valores comecem na margem esquerda.

items <- c('Pen', 'Notebook', 'Stapler')
prices <- c(1.5, 4.99, 7.25)
for (i in seq_along(items)) {
  cat(formatC(items[i], width = 12, flag = '-'),
      formatC(prices[i], format = 'f', digits = 2, width = 8),
      '\n')
}

formatC() com formatos numéricos

formatC() aceita códigos de formato: 'f' para decimal fixo, 'e' para notação científica, 'g' para escolher o mais curto entre os dois e 'd' para inteiros. O argumento digits controla a precisão.

x <- 12345.6789
formatC(x, format = 'f', digits = 2)
formatC(x, format = 'e', digits = 3)
formatC(x, format = 'g', digits = 5)
formatC(42L, format = 'd', width = 8)

format() — Alinhamento do R básico

format(x, width = n, justify = 'left'/'right'/'centre') é a função genérica de alinhamento. Ela funciona com qualquer objeto do R e retorna um vetor de caracteres cujas cadeias têm a mesma largura. A justificativa padrão para números é à direita; para cadeias, à esquerda.

words <- c('cat', 'elephant', 'ox')
format(words, width = 10)
format(words, width = 10, justify = 'right')

format() para precisão numérica

format() também controla as casas decimais com nsmall (número mínimo de dígitos após o decimal) e big.mark para separadores de milhares. Essas opções são ideais para exibir valores financeiros.

format(1234567.8,  big.mark = ',', nsmall = 2)
format(0.1,        nsmall = 4)
format(c(1.5, 100, 0.005), nsmall = 3)

strrep() — Repetição de cadeias

strrep(x, times) repete uma cadeia um determinado número de vezes. Use-o para criar linhas separadoras, cadeias de preenchimento ou elementos decorativos visuais sem concatenar caracteres manualmente.

strrep('-', 40)
strrep('=-', 20)
strrep(c('ab', 'cd'), c(3, 2))
# Draw a simple table border
cat(strrep('=', 30), '\n')

Como criar uma tabela de texto de largura fixa

Combine formatC() com cat() e strrep() para criar uma tabela organizada em texto simples. Esse padrão é comum em ferramentas de CLI e arquivos de registro.

header <- paste0(formatC('Name',  width=12,flag='-'),
                 formatC('Score', width=8,flag='-'),
                 formatC('Grade', width=8,flag='-'))
cat(header, '\n')
cat(strrep('-', 28), '\n')
row1 <- paste0(formatC('Alice',  width=12,flag='-'),
               formatC(92,width=8),formatC('A',width=8,flag='-'))
cat(row1, '\n')

formatC() ou sprintf() para preenchimento

Tanto formatC() quanto sprintf() podem produzir uma saída preenchida. sprintf() é mais conciso em casos simples; formatC() é mais flexível para aplicar a mesma formatação a um vetor inteiro.

x <- 42
# sprintf approach
sprintf('%10d', x)
sprintf('%-10s', 'hello')
# formatC approach
formatC(x,       width = 10)
formatC('hello', width = 10, flag = '-')

Controle da notação científica

formatC(x, format='e', digits=n) ou options(scipen=999) controla quando o R muda para a notação científica. A opção scipen é uma penalidade; valores maiores suprimem a notação científica por mais tempo antes da mudança.

# Default scipen
print(0.0001234)
print(1234567890)
# Force scientific
formatC(0.0001234, format = 'e', digits = 3)
# Suppress scientific globally
old <- options(scipen = 999)
print(0.0001234)
options(old)

Prática: preenchimento de identificadores e rótulos

Uma necessidade comum é usar identificadores preenchidos com zeros ou rótulos preenchidos à esquerda em relatórios. formatC() lida com ambos: use flag = '0' para preencher números com zeros e flag = '-' para alinhar cadeias à esquerda.

ids    <- c(1, 12, 123)
names  <- c('Alice', 'Bob', 'Carol')
scores <- c(88.5, 91.0, 76.25)
for (i in seq_along(ids)) {
  cat(formatC(ids[i], width=5, format='d', flag='0'),
      formatC(names[i], width=10, flag='-'),
      formatC(scores[i], width=8, format='f', digits=2),
      '\n')
}

Verificação rápida

Qual argumento de formatC() faz com que a saída fique alinhada à esquerda dentro da largura especificada?

Preenchimento e alinhamento: principais conclusões

Principais conclusões sobre preenchimento e alinhamento de cadeias:

formatC(x, width=n) preenche à direita até a largura n; flag='-' alinha à esquerda
formatC(x, format='f', digits=2) para decimal fixo; 'e' para notação científica
format(x, justify='left'/'right'/'centre') para alinhamento genérico
format(x, big.mark=',', nsmall=2) para separadores de milhares e casas decimais finais
strrep(s, n) repete uma cadeia n vezes — ótimo para linhas separadoras
Combine com cat() para produzir tabelas em texto simples

cat(strrep('=', 30), '\n')
cat(formatC('Item', width=12, flag='-'),
    formatC('Price', width=10), '\n')
cat(strrep('-', 30), '\n')
cat(formatC('Apple', width=12, flag='-'),
    formatC(1.99, width=10, format='f', digits=2), '\n')

Perguntas Frequentes

A aula “Preenchimento e alinhamento de strings” é grátis?

Sim — o texto completo de “Preenchimento e alinhamento de strings” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Preenchimento e alinhamento de strings”?

Use formatC() e format() para saída de texto com largura fixa e alinhada. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Preenchimento e alinhamento de strings”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy