0Pricing
R Academy · Pelajaran

Prioritas Operator dan Ekspresi Kompleks

Pahami urutan evaluasi dan tulis ekspresi kompleks dengan aman.

Prioritas Operator dan Ekspresi Kompleks adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Apa Itu Prioritas Operator?

Prioritas operator menentukan urutan evaluasi operasi dalam sebuah ekspresi. Seperti dalam matematika, perkalian dievaluasi sebelum penjumlahan. R mengikuti tabel prioritas yang telah ditentukan dengan jelas.

# Precedence in action
result1 <- 2 + 3 * 4    # * before +
result2 <- (2 + 3) * 4  # parentheses override
cat('2 + 3 * 4 =', result1, '
')   # 14
cat('(2+3) * 4 =', result2, '
')   # 20

Tabel Prioritas R (Tinggi ke Rendah)

R mengevaluasi operator dalam urutan berikut (prioritas tertinggi terlebih dahulu):

  1. ^ — perpangkatan
  2. - (unari) — negasi
  3. : — urutan
  4. %%, %/%, %*%, %in% — infix khusus
  5. *, / — perkalian, pembagian
  6. +, - (biner) — penjumlahan, pengurangan
  7. <, >, <=, >=, ==, != — perbandingan
  8. ! — NOT
  9. &, && — AND
  10. |, || — OR
  11. <-, = — penugasan
# Exponentiation before multiplication
cat('2 * 3 ^ 2 =', 2 * 3 ^ 2, '
')   # 2 * 9 = 18
cat('(2*3)^2 =', (2 * 3) ^ 2, '
')   # 6^2 = 36

# Unary minus applied after exponentiation
cat('-2 ^ 2 =', -2 ^ 2, '
')    # -(2^2) = -4
cat('(-2)^2 =', (-2) ^ 2, '
')  # 4

Prioritas Operator Titik Dua

Operator urutan : memiliki prioritas lebih tinggi daripada + dan -, sehingga menimbulkan kesalahan umum bagi pemula: 1:n+1 dibaca sebagai (1:n)+1, bukan 1:(n+1).

n <- 5

# Common mistake: colon before addition
cat('1:n+1 =', 1:n + 1, '
')   # (1:5)+1 = 2 3 4 5 6
cat('1:(n+1) =', 1:(n + 1), '
') # 1:6 = 1 2 3 4 5 6

# These are DIFFERENT results!
# Always use parentheses when the upper bound involves arithmetic

Prioritas Operator Khusus

Operator khusus seperti %%, %/%, dan %in% memiliki prioritas lebih tinggi daripada + dan -, tetapi lebih rendah daripada ^. Kesalahpahaman mengenai hal ini dapat menyebabkan kesalahan yang sulit terlihat.

# %% has higher precedence than +
cat('10 + 7 %% 3 =', 10 + 7 %% 3, '
')   # 10 + (7%%3) = 10+1 = 11
cat('(10+7) %% 3 =', (10 + 7) %% 3, '
') # 17 %% 3 = 2

# %in% precedence
nums <- 1:5
cat('1 + 1 %in% nums =', 1 + 1 %in% nums, '
')  # (1+1) %in% nums? No! 1 + (1 %in% nums) = 2

Perbandingan Sebelum Logika

Operator perbandingan (<, >, ==, dan sebagainya) dievaluasi sebelum operator logika (!, &, |). Artinya, x > 0 & y < 10 bekerja seperti yang diharapkan tanpa tanda kurung tambahan.

x <- 5
y <- 8

# This works as intended: comparisons first, then &
cat('x > 0 & y < 10:', x > 0 & y < 10, '
')  # TRUE & TRUE = TRUE

# ! NOT has higher precedence than &
vec <- c(TRUE, FALSE, TRUE)
cat('!vec & TRUE:', !vec & TRUE, '
')  # (!vec) & TRUE, not !(vec & TRUE)
cat('!(vec & TRUE):', !(vec & TRUE), '
')

Kesalahan Prioritas yang Menjebak #1

Kesalahan umum: lupa bahwa ! memiliki prioritas lebih rendah daripada perbandingan. Artinya, !x == y dibaca sebagai (!x) == y, bukan !(x == y).

x <- 5
y <- 5

# BUG: meant to check 'x is not equal to y'
bug_result <- !x == y      # reads as (!x) == y
cat('!x == y (bug):', bug_result, '
')   # !5 means FALSE, FALSE==5 is FALSE

# CORRECT: use != or !(x == y)
cat('x != y:', x != y, '
')             # FALSE (correct)
cat('!(x == y):', !(x == y), '
')       # FALSE (correct)

Kesalahan Prioritas yang Menjebak #2

Kesalahan lain yang sulit terlihat: -1:5 membuat urutan -1, 0, 1, 2, 3, 4, 5 — tanda minus unari hanya berlaku untuk 1, bukan untuk seluruh rentang. Untuk mendapatkan rentang yang dimulai dari bilangan negatif, gunakan tanda kurung.

# Misleading: looks like range from -1 to 5 starting at negative
seq1 <- -1:5
cat('-1:5 =', seq1, '
')  # -1 0 1 2 3 4 5 (correct here)

# But -2^2 is a trap:
cat('-2^2 =', -2 ^ 2, '
')    # -4 (not 4)
cat('(-2)^2 =', (-2) ^ 2, '
') # 4

# Always parenthesise to be safe
cat('(-1):5 =', (-1):5, '
')   # same as -1:5 but explicit

Menggunakan Tanda Kurung agar Jelas

Meskipun tanda kurung tidak benar-benar diperlukan, penggunaannya membuat kode lebih mudah dibaca dan mengurangi kemungkinan kesalahan. Jangan pernah mengandalkan hafalan seluruh tabel prioritas — gunakan tanda kurung untuk menyatakan maksud Anda dengan jelas.

# Hard to read — requires knowing precedence
result_unclear <- 2 + 3 * 4 ^ 2 / 8 - 1

# Clear intent with parentheses
result_clear <- 2 + ((3 * (4 ^ 2)) / 8) - 1

cat('Unclear:', result_unclear, '
')
cat('Clear:  ', result_clear, '
')
cat('Same result?', result_unclear == result_clear, '
')

Penugasan dalam Ekspresi

Penugasan (<-) memiliki prioritas yang sangat rendah — lebih rendah daripada sebagian besar operator. Artinya, Anda dapat menetapkan hasil ekspresi kompleks dalam satu baris, tetapi ini juga berarti penugasan di dalam ekspresi dapat berperilaku tidak terduga.

# <- has very low precedence
# This assigns (3 + 4) to x, then evaluates (TRUE)
result <- x <- 3 + 4   # x gets 7, result gets 7
cat('x:', x, 'result:', result, '
')

# Be careful with == vs <- 
# x <- 5 is assignment
# x == 5 is comparison (always use == for testing)

Praktik: Menghindari Kesalahan Prioritas

Berikut strategi praktis untuk menulis ekspresi kompleks yang benar: pecah ekspresi panjang menjadi langkah-langkah perantara yang diberi nama. Cara ini juga memudahkan penelusuran kesalahan karena Anda dapat memeriksa setiap langkah.

# Complex formula: compound interest
principal <- 1000
rate <- 0.05
years <- 10

# Hard to verify in one line
bad <- principal * (1 + rate) ^ years

# Easier to verify step by step
growth_factor <- (1 + rate) ^ years
final_amount <- principal * growth_factor
cat('Growth factor:', round(growth_factor, 4), '
')
cat('Final amount: $', round(final_amount, 2), '
')

Prioritas dengan AND/OR Logika

& (AND) memiliki prioritas lebih tinggi daripada | (OR). Jadi, A | B & C dievaluasi sebagai A | (B & C). Selalu gunakan tanda kurung ketika mencampur AND dan OR untuk menghindari kesalahan logika yang sulit terlihat.

A <- TRUE
B <- FALSE
C <- TRUE

# & before | — may surprise you
cat('A | B & C:', A | B & C, '
')     # A | (B & C) = TRUE | FALSE = TRUE
cat('(A|B) & C:', (A | B) & C, '
')   # TRUE & TRUE = TRUE

# Different with:
A2 <- FALSE
cat('A2 | B & C:', A2 | B & C, '
')   # FALSE | (FALSE & TRUE) = FALSE
cat('(A2|B) & C:', (A2 | B) & C, '
') # (FALSE|FALSE) & TRUE = FALSE

Pemeriksaan Singkat

Menjadi berapa hasil evaluasi -3 ^ 2 di R?

Rangkuman: Prioritas Operator

Sangat baik! Berikut inti pembelajaran dari pelajaran ini:

  • Urutan prioritas (tinggi → rendah): ^, - unari, :, %%/%/%*%%in%, */, +-, perbandingan, !, &, |, penugasan
  • -2^2 = -4 karena ^ memiliki prioritas lebih tinggi daripada minus unari — gunakan (-2)^2 untuk mendapatkan 4
  • 1:n+1 berarti (1:n)+1 — gunakan 1:(n+1) jika menginginkan rentang yang lebih panjang
  • & memiliki prioritas lebih tinggi daripada | — gunakan tanda kurung pada logika AND/OR campuran
  • Jika ragu, gunakan tanda kurung untuk memperjelas maksud Anda dan menghindari kesalahan
# Golden rule: parentheses for clarity
n <- 4
# Intended: sequence 1 to n+1
cat('Wrong : 1:n+1  =', 1:n + 1, '
')
cat('Correct: 1:(n+1)=', 1:(n + 1), '
')

# Intended: -(2^2)
cat('Correct: -2^2 = -(2^2) =', -2 ^ 2, '
')

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Prioritas Operator dan Ekspresi Kompleks” gratis?

Ya — teks lengkap “Prioritas Operator dan Ekspresi Kompleks” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Prioritas Operator dan Ekspresi Kompleks”?

Pahami urutan evaluasi dan tulis ekspresi kompleks dengan aman. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Prioritas Operator dan Ekspresi Kompleks” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Operator Aritmetika dan Perbandingan
  2. Operator Logika dan Logika Boolean
  3. Operator Penugasan dan Khusus
  4. Prioritas Operator dan Ekspresi Kompleks
← Kembali ke R Academy