تبدیل مختصات

توابع پیشتر در مفهوم مبانی معرفی شدند، با مثال‌هایی مانند این:

squareit <- function(x) {
    x * x
}

squareit(3)
#> [1] 9

# shorter form
squareit_short <- function(x) x ^ 2

اگر کمی دقیق‌تر به تعریف squareit نگاه کنیم، می‌توانیم بخش‌های مختلفی را تشخیص دهیم:

• تابع یک آرگومان صوری به اسم x می‌پذیرد.
• بدنه‌ای برای تابع وجود دارد که معمولاً داخل آکولادهای { } نوشته می‌شود.
• وقتی شیء تابع ساخته شد، به متغیری به اسم squareit انتساب داده می‌شود.

تابع در R یک شیء درجه‌یک است، تقریباً مثل عددها و رشته‌ها. بنابراین squareit <- function... یک انتساب است که از نظر نحوه‌ی نگارش دقیقاً مثل x <- 42 است.

آرگومان‌ها

R بین آرگومان‌های مکانی و آرگومان‌های کلیدواژه‌ای تفاوت روشنی قائل نمی‌شود، برخلاف دیگر زبان‌های اسکریپتی مثل Python و Julia.

فراخوانی تابع می‌تواند مقادیر را به‌صورت مکانی یا با اسم ارسال کند. حالت دوم برای توابع پیچیده‌ای که آرگومان‌های زیادی دارند و به خاطر سپردن ترتیبشان سخت است، مفید است.

f <- function(x, y) x / y

# call positionally
f(4, 2)
#> [1] 2

# call by name
f(y = 2, x = 4)
#> [1] 2

آرگومان‌های اختیاری

مقادیر پیش‌فرض آرگومان‌ها را می‌توان در تعریف تابع مشخص کرد، اما باید بعد از همه‌ی آرگومان‌های بدون پیش‌فرض بیایند.

بعد می‌توانیم انتخاب کنیم که مقدار پیش‌فرض را بپذیریم یا آن را بازنویسی کنیم.

g <- function(x, y = 2) x / y

# default y value
g(6)
#> [1] 3

# explicit y value
g(6, 3)
#> [1] 2

آرگومان‌های اضافه

برای پذیرفتن تعداد دلخواهی آرگومان اضافه، در تعریف تابع از ... (سه‌نقطه) استفاده کنید. می‌توان هر مقدار اضافه‌ای را که در فراخوانی تابع داده شده به یک بردار تبدیل کرد، اما کمی جلوتر بخوانید تا راه جایگزینی برای استفاده از این «آرگومان‌های نقطه‌ای» (که در چند زبان دیگر «varargs» نامیده می‌شوند) را ببینید.

var_f <- function(x, y, ...) {
  print(c(...))
}

var_f(2, 3, "opt1", "opt2")
#> [1] "opt1" "opt2"

محیط تابع

پیش‌تر گفتیم که آرگومان‌های صوری و بدنه هر دو اجزای یک تابع‌اند.

در واقع، جزء سومی هم وجود دارد: محیطی که تابع در آن تعریف می‌شود.

این را می‌توان با نمونه‌ی توابع تودرتو نشان داد:

outer_func <- function(x) {
  inner_func <- function(y) {
    x * y
  }
  
  inner_func(3)
}

outer_func(5)
#> [1] 15

فراخوانی تابع مقدار x = 5 را به تابع بیرونی می‌فرستد و این مقدار در بدنه‌ی آن تابع در دسترس است.

تابع درونی بخشی از بدنه‌ی تابع بیرونی است و به مقدار x دسترسی دارد. به بیان دیگر، x = 5 در محیط تابع درونی قرار دارد.

از نظر فنی، به این بستار می‌گویند.

محیط به‌ویژه در مورد آرگومان‌های نقطه‌ای مهم است، چون هر مقداری که این‌طور داده شود می‌تواند به فراخوانی‌های تابع در بدنه‌ی تابع منتقل شود. تابع بیرونی لازم نیست بداند یا اهمیت بدهد که آرگومان‌های نقطه‌ای چه معنایی دارند.

f_var <- function(x, ...) {
  sum(x, ...)
}

x <- c(1, 2, NA, 6)

# for sum(), na.rm defaults to FALSE
f_var(x)
#> [1] NA

# pass through the na.rm value
f_var(x, na.rm = TRUE)
#> [1] 9

این تکنیک به‌طور گسترده در کتابخانه‌های Tidyverse مثل stringr استفاده می‌شود. بسیاری از توابع stringr پوششی کاربرپسند حول توابع سطح‌پایین stringi و R پایه‌اند.

آرگومان‌های اضافه‌ای که به توابع str_*() داده می‌شوند، به‌سادگی به همان توابع سطح‌پایین منتقل می‌شوند.

توابع به عنوان مقدار بازگشتی

یک تابع بیرونی می‌تواند یک تابع درونی تعریف کند (چه نام‌دار، چه بی‌نام، همان‌طور که پایین‌تر توضیح داده می‌شود) و آن را به عنوان مقدار بازگشتی به کار ببرد.

تابع بازگردانده‌شده محیطی را که در آن تعریف شده با خود دارد.

times_y <- function(x) {
  # anonymous function - see next section
  \(y) x * y
}

f <- times_y(3)
class(f)
#> [1] "function"

f(4)
#> [1] 12

توابع بی‌نام

وقتی تابعی تعریف می‌کنیم، معمولاً شیء تابع حاصل را به یک متغیر متصل می‌کنیم.

x <- 2

# function definition captures x from the environment
doubleit_short <- function(y) x * y

این کار استفاده از تابع را در ادامه‌ی اسکریپت آسان می‌کند، اما چنین اتصالی ضروری نیست. یک تابع کوتاه که فقط یک بار استفاده می‌شود می‌تواند همان‌جا مفید باشد. بدون اتصال به اسم، به آن تابع بی‌نام می‌گویند.

استفاده از توابع بی‌نام آن‌قدر رایج است که (از نسخه‌ی ۴.۱.۰ زبان R به بعد) یک نحوه‌ی نگارش کوتاه‌شده برای تعریفشان وجود دارد: کلمه‌ی function را با یک بک‌اسلش \ جایگزین کنید.

نمونه‌ای از این را در بخش قبلی، درباره‌ی مقادیر بازگشتی، دیدیم.

کپی هنگام تغییر

R اجازه می‌دهد به عنصرهای جداگانه‌ی یک بردار مقدار انتساب دهیم. اگر برداری را به عنوان آرگومان تابع بفرستیم و آن را در بدنه‌ی تابع پیش از بازگرداندن تغییر دهیم، یک بردار تغییرکرده به دست می‌آوریم.

اما بردار اصلی چه شد؟

f <- function(vec) {
  vec[1] <- 42
  vec
}

vals <- c(1, 3, 4)

# f() returns a modified vector
f(vals)
#> [1] 42  3  4  

# the original vector is unchanged.
vals
#> [1] 1 3 4

R زبانی است که برای علم داده طراحی شده است. جمع‌آوری آن داده‌ها می‌تواند زمان و تلاش زیادی و شاید مبلغ سرسام‌آوری پول هزینه بردارد: مهم است که آن‌ها را خراب نکنیم!

سیاست کلی (با چند استثنا) کپی هنگام تغییر است. اگر شیئی (مثل یک بردار) طوری تغییر کند که بعداً دردسر ایجاد کند، R یک کپی تغییرکرده برمی‌گرداند و اصل را دست‌نخورده رها می‌کند.

کپی کردن ساختارهای داده‌ی بزرگ می‌تواند از نظر محاسباتی گران باشد، اما وقتی جایگزینش خراب شدن داده باشد، معمولاً این شر کمتر است.