ฟังก์ชัน R
ฟังก์ชันคือบล็อกของโค้ดที่ทำงานเมื่อมีการเรียกเท่านั้น
คุณสามารถส่งข้อมูลที่เรียกว่าพารามิเตอร์ไปยังฟังก์ชันได้
ฟังก์ชันสามารถส่งคืนข้อมูลได้
การสร้างฟังก์ชัน
ในการสร้างฟังก์ชัน ใช้function()คำสำคัญ:
ตัวอย่าง
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
เรียกใช้ฟังก์ชัน
หากต้องการเรียกใช้ฟังก์ชัน ให้ใช้ชื่อฟังก์ชันตามด้วยวงเล็บ เช่นmy_function() :
ตัวอย่าง
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
ข้อโต้แย้ง
ข้อมูลสามารถส่งผ่านไปยังฟังก์ชันเป็นอาร์กิวเมนต์ได้
อาร์กิวเมนต์ถูกระบุหลังชื่อฟังก์ชัน ภายในวงเล็บ คุณสามารถเพิ่มอาร์กิวเมนต์ได้มากเท่าที่ต้องการ เพียงแค่คั่นด้วยเครื่องหมายจุลภาค
ตัวอย่างต่อไปนี้มีฟังก์ชันที่มีหนึ่งอาร์กิวเมนต์ (fname) เมื่อเรียกใช้ฟังก์ชัน เราจะส่งต่อชื่อ ซึ่งใช้ในฟังก์ชันเพื่อพิมพ์ชื่อเต็ม:
ตัวอย่าง
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
พารามิเตอร์หรืออาร์กิวเมนต์?
คำว่า "พารามิเตอร์" และ "อาร์กิวเมนต์" สามารถใช้ในสิ่งเดียวกัน นั่นคือ ข้อมูลที่ส่งผ่านไปยังฟังก์ชัน
จากมุมมองของฟังก์ชัน:
พารามิเตอร์คือตัวแปรที่อยู่ในวงเล็บในนิยามฟังก์ชัน
อาร์กิวเมนต์คือค่าที่ส่งไปยังฟังก์ชันเมื่อมีการเรียก
จำนวนอาร์กิวเมนต์
โดยค่าเริ่มต้น ต้องเรียกใช้ฟังก์ชันด้วยจำนวนอาร์กิวเมนต์ที่ถูกต้อง หมายความว่าหากฟังก์ชันของคุณคาดหวัง 2 อาร์กิวเมนต์ คุณต้องเรียกใช้ฟังก์ชันที่มี 2 อาร์กิวเมนต์ ไม่มากและไม่น้อย:
ตัวอย่าง
ฟังก์ชันนี้คาดหวัง 2 อาร์กิวเมนต์ และรับ 2 อาร์กิวเมนต์:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
หากคุณพยายามเรียกใช้ฟังก์ชันด้วย 1 หรือ 3 อาร์กิวเมนต์ คุณจะได้รับข้อผิดพลาด:
ตัวอย่าง
ฟังก์ชันนี้ต้องการ 2 อาร์กิวเมนต์ และรับ 1 อาร์กิวเมนต์:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
ค่าพารามิเตอร์เริ่มต้น
ตัวอย่างต่อไปนี้แสดงวิธีการใช้ค่าพารามิเตอร์เริ่มต้น
หากเราเรียกใช้ฟังก์ชันโดยไม่มีอาร์กิวเมนต์ ฟังก์ชันจะใช้ค่าเริ่มต้น:
ตัวอย่าง
my_function <- function(country = "Norway") {
paste("I am
from", country)
}
my_function("Sweden")
my_function("India")
my_function()
# will get the default value, which is Norway
my_function("USA")
ส่งกลับค่า
หากต้องการให้ฟังก์ชันส่งคืนผลลัพธ์ ให้ใช้return()ฟังก์ชัน:
ตัวอย่าง
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
ผลลัพธ์ของโค้ดด้านบนจะเป็น:
[1] 15
[1] 25
[1] 45
ฟังก์ชั่นซ้อนกัน
มีสองวิธีในการสร้างฟังก์ชันที่ซ้อนกัน:
- เรียกใช้ฟังก์ชันภายในฟังก์ชันอื่น
- เขียนฟังก์ชันภายในฟังก์ชัน
ตัวอย่าง
เรียกใช้ฟังก์ชันภายในฟังก์ชันอื่น:
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
ตัวอย่างที่อธิบาย
ฟังก์ชันบอก x ให้บวก y
อินพุตแรก Nested_function(2,2) คือ "x" ของฟังก์ชันหลัก
อินพุตที่สอง Nested_function(3,3) คือ "y" ของฟังก์ชันหลัก
ผลลัพธ์ที่ได้คือ (2+2) + (3+3) = 10
ตัวอย่าง
เขียนฟังก์ชันภายในฟังก์ชัน:
Outer_func <- function(x) {
Inner_func <- function(y) {
a <- x + y
return(a)
}
return
(Inner_func)
}
output <- Outer_func(3) # To
call the Outer_func
output(5)
ตัวอย่างที่อธิบาย
คุณไม่สามารถเรียกใช้ฟังก์ชันได้โดยตรง เนื่องจากมีการกำหนด Inner_func (ซ้อนอยู่) ภายใน Outer_func
เราต้องเรียก Outer_func ก่อน ถึงจะเรียก Inner_func เป็นขั้นตอนที่ 2 ได้
เราจำเป็นต้องสร้างตัวแปรใหม่ที่เรียกว่า output และให้ค่าซึ่งก็คือ 3 ตรงนี้
จากนั้นเราพิมพ์ผลลัพธ์ด้วยค่าที่ต้องการของ "y" ซึ่งในกรณีนี้คือ 5
ผลลัพธ์จึงเป็น8 (3 + 5)
การเรียกซ้ำ
R ยังยอมรับการเรียกซ้ำของฟังก์ชัน ซึ่งหมายความว่าฟังก์ชันที่กำหนดสามารถเรียกตัวเองได้
การเรียกซ้ำเป็นแนวคิดทางคณิตศาสตร์และการเขียนโปรแกรมทั่วไป หมายความว่าฟังก์ชันเรียกตัวเอง สิ่งนี้มีประโยชน์ในความหมายที่คุณสามารถวนซ้ำข้อมูลเพื่อให้ได้ผลลัพธ์
นักพัฒนาซอฟต์แวร์ควรระมัดระวังอย่างยิ่งกับการเรียกซ้ำเนื่องจากการเขียนฟังก์ชันที่ไม่มีวันสิ้นสุดหรือฟังก์ชันที่ใช้หน่วยความจำหรือโปรเซสเซอร์มากเกินไปอาจทำได้ง่ายมาก อย่างไรก็ตาม เมื่อเขียนอย่างถูกต้อง การเรียกซ้ำอาจเป็นวิธีการเขียนโปรแกรมที่มีประสิทธิภาพและสง่างามทางคณิตศาสตร์
ในตัวอย่างtri_recursion()นี้ เป็นฟังก์ชันที่เรากำหนดให้เรียกตัวเอง ("recurse") เราใช้
kตัวแปรเป็นข้อมูล ซึ่งจะลดค่า ( -1) ทุกครั้งที่เรียกซ้ำ การเรียกซ้ำจะสิ้นสุดลงเมื่อเงื่อนไขไม่มากกว่า 0 (เช่น เมื่อเป็น 0)
สำหรับนักพัฒนาใหม่ อาจต้องใช้เวลาสักพักกว่าจะรู้ว่าสิ่งนี้ทำงานอย่างไร วิธีที่ดีที่สุดในการค้นหาคือการทดสอบและแก้ไข
ตัวอย่าง
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)