R Academy · Aula

Operadores lógicos e lógica booleana

Entenda &, |, !, xor(), any() e all() para operações booleanas.

Operadores lógicos e lógica booleana é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 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.

Introdução à lógica booleana

A lógica booleana é a base da tomada de decisões na programação. Em R, os valores lógicos são TRUE e FALSE. Os operadores lógicos combinam esses valores para formar condições complexas.

# Boolean values in R
is_raining <- TRUE
is_cold <- FALSE
cat('Is raining:', is_raining, '
')
cat('Is cold:', is_cold, '
')
cat('Class:', class(is_raining), '
')

E elemento a elemento com &

O operador & executa E elemento a elemento em vetores. Ele retorna TRUE somente quando ambos os elementos correspondentes são TRUE. O operador processa todos os elementos de um vetor.

ages <- c(15, 22, 17, 30, 19)
has_id <- c(FALSE, TRUE, FALSE, TRUE, TRUE)

# Can buy alcohol? (must be 18+ AND have ID)
can_buy <- (ages >= 18) & has_id
cat('Ages >= 18:', ages >= 18, '
')
cat('Has ID:', has_id, '
')
cat('Can buy:', can_buy, '
')

OU elemento a elemento com |

O operador | executa OU elemento a elemento. Ele retorna TRUE quando pelo menos um dos elementos correspondentes é TRUE.

scores_math <- c(85, 45, 72, 38, 90)
scores_english <- c(40, 88, 65, 70, 55)

# Pass if either subject >= 60
passes <- (scores_math >= 60) | (scores_english >= 60)
cat('Math pass:', scores_math >= 60, '
')
cat('English pass:', scores_english >= 60, '
')
cat('Overall pass:', passes, '
')

NÃO lógico com !

O operador ! nega um valor lógico, invertendo TRUE para FALSE e vice-versa. Ele é aplicado antes de & e | na ordem de avaliação.

is_weekend <- c(TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE)
cat('Is weekend:', is_weekend, '
')
cat('Is weekday:', !is_weekend, '
')

# Count weekdays
cat('Number of weekdays:', sum(!is_weekend), '
')

E escalar com &&

&& é a versão escalar de E — ela avalia apenas o primeiro elemento de cada vetor e usa avaliação de curto-circuito: se o lado esquerdo for FALSE, o lado direito nunca será avaliado.

x <- 10

# Short-circuit: second condition skipped if first is FALSE
if (x > 0 && x < 100) {
  cat('x is a positive double-digit or less
')
}

# && only looks at first element
cat('TRUE && FALSE:', TRUE && FALSE, '
')
cat('TRUE & FALSE (vectorised):', TRUE & FALSE, '
')

OU escalar com ||

|| é a versão escalar de OU com avaliação de curto-circuito: se o lado esquerdo for TRUE, o lado direito nunca será avaliado. Use || em instruções if quando precisar de apenas um resultado.

user_role <- 'admin'

# Short-circuit OR — stops at first TRUE
if (user_role == 'admin' || user_role == 'superuser') {
  cat('Access granted
')
} else {
  cat('Access denied
')
}

cat('FALSE || TRUE:', FALSE || TRUE, '
')

OU exclusivo com xor()

xor(x, y) retorna TRUE quando exatamente um de x ou y é TRUE. Ele retorna FALSE quando ambos são iguais. É útil para lógica de alternância.

# xor truth table
cat('xor(TRUE, TRUE):', xor(TRUE, TRUE), '
')   # FALSE
cat('xor(TRUE, FALSE):', xor(TRUE, FALSE), '
')  # TRUE
cat('xor(FALSE, TRUE):', xor(FALSE, TRUE), '
')  # TRUE
cat('xor(FALSE, FALSE):', xor(FALSE, FALSE), '
') # FALSE

# Practical: exactly one sensor triggered
sensor_a <- c(TRUE, FALSE, TRUE, FALSE)
sensor_b <- c(FALSE, FALSE, TRUE, TRUE)
cat('Exactly one sensor:', xor(sensor_a, sensor_b), '
')

any() e all()

any() retorna TRUE se pelo menos um elemento for TRUE. all() retorna TRUE somente se todos os elementos forem TRUE. Ambas reduzem um vetor lógico a um único valor.

temperatures <- c(22.1, 24.5, 19.8, 31.2, 28.0)

cat('Any temperature above 30?', any(temperatures > 30), '
')
cat('All temperatures above 15?', all(temperatures > 15), '
')
cat('All temperatures above 25?', all(temperatures > 25), '
')

# Useful for data validation
test_scores <- c(78, 85, 92, 88, 76)
cat('All passed (>=60)?', all(test_scores >= 60), '
')

Combinação de operadores lógicos

O senhor pode encadear vários operadores lógicos para criar condições complexas. O R avalia primeiro !, depois & e, em seguida, |. Use parênteses para deixar clara a sua intenção.

age <- 25
income <- 55000
credit_score <- 720

# Loan eligibility: age 21-65, income >= 40000, credit >= 700
eligible <- (age >= 21 && age <= 65) &&
            (income >= 40000) &&
            (credit_score >= 700)
cat('Loan eligible:', eligible, '
')

Operadores lógicos em quadros de dados

Os operadores lógicos são especialmente úteis ao filtrar quadros de dados. O senhor pode combinar várias condições para selecionar exatamente as linhas necessárias.

# Simple data frame
names_vec <- c('Alice', 'Bob', 'Carol', 'Dave', 'Eve')
ages_vec <- c(28, 35, 22, 45, 31)
salaries <- c(55000, 72000, 38000, 90000, 61000)

# Filter: age 25-40 AND salary above 50000
mask <- (ages_vec >= 25 & ages_vec <= 40) & (salaries > 50000)
cat('Matching employees:', names_vec[mask], '
')

Aritmética booleana

Em R, TRUE é tratado como 1 e FALSE como 0 em operações aritméticas. Isso significa que o senhor pode usar sum() para contar valores TRUE e mean() para obter a proporção.

responses <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, FALSE, TRUE)

cat('Number of TRUE:', sum(responses), '
')
cat('Proportion TRUE:', mean(responses), '
')
cat('Percentage:', mean(responses) * 100, '%
')

# Count values meeting a condition
scores <- c(88, 45, 92, 61, 73, 55, 84)
cat('Number passing (>=60):', sum(scores >= 60), '
')

Verificação rápida

Qual é a diferença entre & e && em R?

Recapitulação: lógica booleana em R

Excelente! Veja os principais pontos desta lição:

& e | são vetorizados — comparam elemento por elemento
&& e || são escalares e usam avaliação de curto-circuito — use-os em instruções if
! nega um valor lógico
xor() retorna TRUE quando exatamente um argumento é TRUE
any() e all() reduzem vetores lógicos a um único valor
TRUE == 1 e FALSE == 0, portanto o senhor pode somar ou calcular a média de vetores lógicos

# Summary: all logical operators at a glance
x <- c(TRUE, FALSE, TRUE)
y <- c(TRUE, TRUE, FALSE)
cat('x & y :', x & y, '
')
cat('x | y :', x | y, '
')
cat('!x    :', !x, '
')
cat('xor   :', xor(x, y), '
')
cat('any(x):', any(x), '
')
cat('all(x):', all(x), '
')

Perguntas Frequentes

A aula “Operadores lógicos e lógica booleana” é grátis?

Sim — o texto completo de “Operadores lógicos e lógica booleana” é 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 “Operadores lógicos e lógica booleana”?

Entenda &, |, !, xor(), any() e all() para operações booleanas. 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 2 de 4.

Quanto tempo leva a aula “Operadores lógicos e lógica booleana”?

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

Operadores aritméticos e de comparação
Operadores lógicos e lógica booleana
Atribuição e operadores especiais
Precedência de operadores e expressões complexas

← Voltar para R Academy