Skip to main content

Pengantar Pemrograman R dan RStudio Untuk Statistika dan Data Science

Bab 7 Operator Pipe

Operator pipe di R sudah dikenal sejak adanya package magrittr release. Package ini menyediakan berbagai operator, salah satunya adalah operator %>% (pipe). Operator ini kemudian diminati oleh banyak pengguna R terutama karena kemudahan penggunaannya bersama fungsi-fungsi dari package tidyverse.

Melihat hal ini, tim pengembang core R akhirnya memutuskan untuk membuat operator pipe milik R sendiri (bukan dari package) pada release R versi 4.1.0. Namun operator pipe ini tampilannya berbeda, yaitu |> (dibaca native pipe operator atau native pipe). Dari fungsinya, operator pipe %>% dan |> memiliki tujuan yang sama.

7.1 Apa itu operator Pipe?

Pipe operator adalah sebuah operator di R yang pertama kali dikenalkan pada package magrittr. Operator ini digunakan untuk membuat “rantai” proses atau urutan function. Operator pipe %>% atau |> dapat kita anggap sebagai kata sambung “selanjutnya”, “kemudian” atau yang setara dengan itu dalam sebuah kalimat atau paragraf.

7.2 Cara kerja operator Pipe

Bayangkan kita sebagai manusia yang setiap hari melakukan banyak aktivitas, mulai dari bangun tidur hingga tidur lagi. Ketika seorang manusia pertama kali beraktivitas mengawali hari, umumnya yang pertama kali dilakukan adalah membuka mata. Setelah membuka mata kemudian bangun dari tempat tidur. Selanjutnya dia pergi ke kamar mandi. Di kamar mandi dia melakukan aktivitas selama beberapa waktu. Setelah selesai selanjutnya dia keluar dari kamar mandi dan dia memakai pakaian. Setelah itu ia sarapan, nasi goreng misalnya, dan kemudian berangkat.

Jika kita analogikan manusia tersebut adalah sebuah objek, misalnya sebuah data, dan aktivitas atau kegiatan yang dilakukan adalah sebuah function maka akan ada urutan function yang dijalankan. Ketika kita buat aktivitas ini berupa program di R maka akan menjadi seperti berikut.

manusia %>%
  buka_mata() %>% 
  bangun_tidur() %>% 
  ke_kamar_mandi() %>% 
  mandi() %>% 
  berpakaian() %>% 
  sarapan() %>% 
  pergi()

Ketika kita bicara tentang function, maka umumnya function akan memiliki argumen yang berisi objek yang akan diproses olehnya. Misalnya mean(1:10) maka mean() adalah sebuah function dan vector 1:10 adalah objek sebagai nilai dari argumen yang akan diproses. Pada contoh program di atas, objek atau hasil dari sebuah function sebelum operator Pipe akan menjadi argumen untuk function setelah operator tersebut.

Secara default objek atau hasil dari sebuah function akan menjadi nilai bagi argumen pertama di function berikutnya. Misalnya ada sebuah function f() dengan argumen x, f(x), kita dapat tuliskan dalam sebuah program menggunakan Pipe seperti berikut.

x %>% f()

Sebagai contoh pada mean(1:10) kita dapat menuliskannya sebagai 1:10 %>% mean(). Jika sebuah function memiliki lebih dari satu argumen, misalnya f(x, y) maka kita dapat menuliskannya dalam bentuk x %>% f(y). Sebagai contoh function mean() juga mempunyai argumen na.rm = TRUE untuk membuang missing value dari perhitungan. Maka mean(1:10, na.rm = TRUE) akan menjadi 1:10 %>% mean(na.rm = TRUE).

Pada kasus function yang memiliki argumen lebih dari satu, jika objek sebelum Pipe yang akan menjadi nilai bagi argumen selain argumen pertama maka kita dapat menggantikan nilai pada argumen tersebut dengan tanda titik.

Contoh pada function sub() yang memiliki argumen pattern, replacement dan x yang harus diisi. Misalnya ada sebuah string, yaitu Gunakan Excel. Kita akan mengganti kata Excel dengan R. Maka dapat kita tuliskan seperti berikut.

sub(pattern = "Excel", replacement = "R", x = "Gunakan Excel")
## [1] "Gunakan R"

Bagaimana jika kita gunakan Pipe? Kita dapat menuliskannya seperti berikut.

library(magrittr)
"Gunakan Excel" %>% sub(pattern = "Excel", replacement = "R", x = .)
## [1] "Gunakan R"

Selanjutnya jika ada sebuah function lain yang dapat memproses hasil dari function f(x), misalnya g(z). Nilai dari argumen z adalah output dari function f(x). Kita tuliskan seperti berikut.

g(z = f(x))

Jika kita ingin menggunakan Pipe maka dapat kita tuliskan seperti berikut.

f(x) %>% g()

# atau 

x %>% f() %>% g()

Biasanya ketika membuat program di R menggunakan Pipe, function setelah Pipe akan dibuat di baris berikutnya. Hal ini dilakukan untuk memudahkan ketika “membaca” sebuah program atau ketika melakukan debugging. Tentu saja ini hanya sebuah kebiasaan dan preferensi seseorang.

x %>% 
  f() %>% 
  g()

7.3 Perbedaan antara %>% dan |>

Meskipun keduanya memiliki tujuan yang sama, yaitu memungkinkan pengguna untuk mengalirkan output dari satu fungsi ke fungsi berikutnya, terdapat beberapa perbedaan penting antara keduanya. Ada beberapa perbedaan antara Native Pipe operator (|>) dan Pipe dari magrittr atau tidyverse (%>%).

1. Asal dan Kompatibilitas

  • Pipe |>: Operator ini adalah fitur bawaan dari R yang diperkenalkan mulai versi 4.1.0. Karena merupakan bagian dari bahasa R, operator ini tidak memerlukan instalasi paket tambahan dan kompatibel dengan semua versi R yang lebih baru dari 4.1.0.

  • Pipe %>%: Operator ini berasal dari paket magrittr dan kemudian diadopsi secara luas oleh paket tidyverse. Untuk menggunakan %>%, pengguna perlu menginstal dan memuat paket magrittr atau tidyverse terlebih dahulu.

2. Sintaksis dan Penulisan

  • Pipe |>: Sintaksisnya lebih sederhana dan lebih dekat dengan sintaksis dasar R. Operator ini hanya mendukung pengaliran output ke argumen pertama atau argumen yang memiliki nama dari fungsi berikutnya. Contohnya pada function paste() yang tidak memiliki nama argumen untuk setiap bagian yang akan digabungkan:
"a" |> paste("b")
## [1] "a b"

Jika kita ingin menggabungkan nilai sebelum operator dengan nilai pada paste() setelah "b" sehingga hasilnya "b a" tidak bisa dengan |> meskipun menggunakan placeholder.

"a" |> paste("b", _) # Ini akan menyebabkan error
## Error in paste("b", "_"): pipe placeholder can only be used as a named argument (<text>:1:8)
  • Pipe %>%: Operator ini lebih fleksibel dan mendukung pengaliran output ke argumen selain yang pertama menggunakan placeholder (.). Contoh:
"a" %>% paste("b", .)
## [1] "b a"

Selain itu, %>% juga mendukung penggunaan lambda function dan operasi lain yang lebih kompleks.

3. Fleksibilitas

  • Pipe |>: Lebih terbatas dalam hal fleksibilitas karena hanya mendukung pengaliran ke argumen pertama atau argumen yang memiliki nama. Jika Anda perlu mengalirkan output ke argumen lain, Anda harus menggunakan fungsi anonim atau menulis ulang kode.

  • Pipe %>%: Lebih fleksibel karena memungkinkan pengaliran ke argumen mana pun menggunakan placeholder (.) seperti pada contoh di atas. Ini memungkinkan penulisan kode yang lebih ekspresif dan ringkas.

4. Kecepatan dan Performa

  • Pipe |>: Karena merupakan bagian dari bahasa R, operator ini cenderung lebih cepat dan memiliki overhead yang lebih rendah dibandingkan dengan %>%.

  • Pipe %>%: Meskipun sangat fleksibel, operator ini memiliki overhead yang sedikit lebih tinggi karena merupakan bagian dari paket eksternal.

5. Dukungan dan Komunitas

  • Pipe |>: Sebagai fitur bawaan, operator ini didukung secara resmi oleh R Core Team dan akan terus dikembangkan dalam versi-versi R mendatang.

  • Pipe %>%: Operator ini memiliki dukungan komunitas yang sangat kuat, terutama dari pengguna tidyverse. Namun, karena merupakan paket eksternal, perkembangannya bergantung pada kontributor paket tersebut.

Kedua pipe operator memiliki kelebihan dan kekurangan masing-masing. Native pipe operator (|>) cocok untuk pengguna yang menginginkan solusi ringan dan terintegrasi langsung dengan R, sementara pipe dari magrittr (%>%) menawarkan fleksibilitas yang lebih besar dan dukungan komunitas yang kuat. Pemilihan antara keduanya tergantung pada kebutuhan spesifik dan preferensi pribadi pengguna.