Different ways to make Method Parameter Optional

ปานประดับ บุญตัน 650710567

พารามิเตอร์ทางเลือก (Optional Parameters) ช่วยให้ไม่ต้องจำเป็นระบุค่าพารามิเตอร์ทุกตัวเมื่อมีการเรียกใช้เมธอด หรือไม่ต้องส่งค่าพารามิเตอร์บางตัวในฟังก์ชันได้ ใน C# มีทั้งหมด 4 วิธี

1.การใช้ค่าเริ่มต้น (Default Value)

ช่วยให้สามารถกำหนดค่าเริ่มต้นให้กับพารามิเตอร์ในนิยามของเมธอดได้ เมื่อไม่มีการส่งค่าพารามิเตอร์เมื่อเรียกใช้ฟังก์ชัน ระบบจะใช้ค่าที่ตั้งไว้เป็นค่าเริ่มต้น และพารามิเตอร์ที่มีค่าเริ่มต้นต้องอยู่ในตำแหน่งสุดท้ายของรายการพารามิเตอร์ในเมธอดเสมอ

using System;

class Program
{
    public void IntroduceYourself(string firstName, string lastName = "Doe")
    {
        Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
    }

    static void Main(string[] args)
    {
        Program program = new Program();
        
        program.IntroduceYourself("John", "Smith"); 
        program.IntroduceYourself("John");
    }
}

บรรทัดที่ 5 : มีการกำหนดค่าเริ่มต้น lastName = "Doe" ในตำแหน่งสุดท้ายของพารามิเตอร์ บรรทัดที่ 15 : สามารถเรียกใช้เมธอดIntroduceYourself โดยส่งแค่พารามิเตอร์ firstName ได้ หากไม่ระบุ lastName ค่าจะเป็น "Doe"

output :

Hello, my name is John Smith
Hello, my name is John Doe

2.การใช้การ Overloading เมธอด (Method Overloading)

เป็นการสร้างเมธอดที่มีชื่อเดียวกันแต่จำนวนพารามิเตอร์ต่างกัน การ Overloadingไม่ใช่แนวทางในการสร้างพารามิเตอร์ทางเลือกจริงๆ แต่เป็นการทำให้ผลลัพธ์คล้ายกับพารามิเตอร์ทางเลือก

using System;

class GFG {
    static public void my_mul(int a) {
        Console.WriteLine(a * a);
    }

    static public void my_mul(int a, int b, int c) {
        Console.WriteLine(a * b * c);
    }

    static public void Main() {
        my_mul(4);
        my_mul(5, 6, 100);
    }
}

บรรทัดที่ 4 : เมธอด my_mul แรกรับอาร์กิวเมนต์ 1 ตัว บรรทัดที่ 8 : เมธอด my_mul อันที่สองรับอาร์กิวเมนต์ 3 ตัว ทำให้ไม่จำเป็นต้องส่งพารามิเตอร์ทุกตัว

output :

16
3000

3.การใช้ OptionalAttribute

ใช้พารามิเตอร์ทางเลือกได้โดยการใช้ OptionalAttribute ต้องเพิ่มเนมสเปซ System.Runtime.InteropServices แล้วใช้คำว่า [Optional] หน้าพารามิเตอร์ในฟังก์ชัน ค่าเริ่มต้นคือ 0

using System;
using System.Runtime.InteropServices;

class GFG {
    static public void my_mul(int num, [Optional] int num2) {
        Console.WriteLine(num * num2);
    }

    static public void Main() {
        my_mul(4); // 4*0
        my_mul(2, 10); // 2*10
    }
}

บรรทัดที่ 2 : เพิ่มเนมสเปซ System.Runtime.InteropServices บรรทัดที่ 5 : พารามิเตอร์ num2 มีค่าคือ 0 อัตโนมัติเมื่อไม่ได้ส่งค่าเข้ามา เพราะ int เป็นชนิดข้อมูลที่มีค่าเริ่มต้นเป็น 0 ใน C#

output :

0 
20

4.การใช้คำสั่ง Params

การใช้พารามิเตอร์ทางเลือกโดยการใช้คีย์เวิด params จะทำให้ส่งพารามิเตอร์จำนวนเท่าใดก็ได้ไปที่เมธอด แต่ใช้ได้กับพารามิเตอร์แค่ตัวเดียว เนื่องจากพารามิเตอร์ที่จะใช้ ต้องเป็นพารามิเตอร์ตัวสุดท้าย ถึงจะไม่ใช่แนวทางของพารามิเตอร์ทางเลือกโดยตรง แต่ก็สามารถให้ผลลัพธ์เดียวกันกับพารามิเตอร์ทางเลือกได้

using System;

class GFG {
    static public void my_mul(int a, params int[] a1) {
        int mul = 1;

        if (a1.Length > 0) {
            foreach (int num in a1) {
                mul *= num;
            }
        } else {
            mul = 1;
        }

        Console.WriteLine(mul * a);
    }

    static public void Main() {
        my_mul(1);
        my_mul(2, 4);
        my_mul(3, 3, 100);
    }
}

บรรทัดที่ 4 : เฟังก์ชัน my_mul รับพารามิเตอร์ a1 โดยรับค่าพารามิเตอร์จำนวนเท่าใดก็ได้ เข้าไปในเมธอด และค่าที่ส่งมาจะถูกเก็บอยู่ในอาเรย์ a1 การใช้ params ช่วยให้ส่งค่าหลายตัวได้โดยไม่จำเป็นต้องส่งในรูปแบบอาเรย์ บรรทัดที่ 21 : มีการเรียกฟังก์ชัน my_mul โดยส่งค่า a=3 และส่งค่า3 และ 100 ให้กับ a1 ซึ่งจะถูกเก็บในอาเรย์ a1 = {3, 100}

output :

1
8
900

เปรียบเทียบกับ C,Java,Python

🔗Parameter Optional in C

ภาษา C ไม่รองรับ default parameters หมายความว่าทุกพารามิเตอร์ต้องระบุค่าเมื่อมีการเรียกใช้ฟังก์ชัน หากไม่ระบุค่าเริ่มต้น ก็จะไม่มีการกำหนดค่าเริ่มต้นให้กับพารามิเตอร์ ซึ่งทำให้ภาษา C ไม่มี parameter optional แต่มีแนวคิดที่สามารถใช้เพื่อจำลองพฤติกรรมคล้ายๆ กับการมีค่าเริ่มต้นได้ ซึ่งก็คือการใช้พารามิเตอร์ที่รับค่าหลายค่า (variable arguments) ผ่านการใช้ไลบรารี <stdarg.h>

#include <stdio.h>
#include <stdarg.h>
int sum(int num, ...) {
    va_list args;
    va_start(args, num);
    int total = 0;
    for (int i = 0; i < num; i++) {
        total += va_arg(args, int);
    }
    va_end(args);
    return total;
}

int main() {
    printf("Sum: %d\n", sum(3, 5, 10, 15));
    return 0;
}

บรรทัดที่ 2 : นำเข้าไลบรารี <stdarg.h> ช่วยให้สามารถใช้พารามิเตอร์ที่รับค่าหลายค่าในฟังก์ชันได้ บรรทัดที่ 3 : ในพารามิเตอร์ของฟังก์ชัน sum ตัวสุดท้ายใช้... เพื่อบอกให้รับจำนวนพารามิเตอร์ที่ไม่จำกัด หรือไม่ส่งค่าก็ได้ บรรทัดที่ 15 : มีการส่งค่า 3 ไปที่ num และส่งค่า 5, 10, 15 ไปยัง ... เพื่อเป็นค่าที่จะถูกรวมกันในฟังก์ชัน

output :

Sum: 30

🔗Parameter Optional in Java

Java ไม่มีการรองรับ Parameter Optional โดยตรง แต่ Java สามารถใช้วิธีต่างๆ เพื่อจำลองพฤติกรรมของ Parameter Optional ได้ เช่น การทำ overloding ,varargs

1.การทำ Overloding

วิธีการนี้เริ่มต้นด้วยเมธอดที่รับเฉพาะพารามิเตอร์ที่จำเป็น จากนั้นสามารถเพิ่มเมธอดที่รองรับพารามิเตอร์ทางเลือกหนึ่งตัว และเพิ่มเมธอดที่รองรับสองพารามิเตอร์ทางเลือกไปเรื่อย ๆ โดยการสร้าง method หลายตัวที่มีชื่อเดียวกัน แต่รับพารามิเตอร์ที่ต่างกัน

public class Example {

    public void display(String mandatory) {
        System.out.println("Mandatory: " + mandatory);
    }

    public void display(String mandatory, String optional) {
        System.out.println("Mandatory: " + mandatory + ", Optional: " + optional);
    }

    public static void main(String[] args) {
        Example example = new Example();
        example.display("Hello"); 
        example.display("Hello", "World"); ง
    }
}

บรรทัดที่ 3 : เมธอด display แรกมีการรับพารามิเตอร์แค่ตัวเดียว คือ mandatory บรรทัดที่ 8 : เมธอด display ที่สองมีการรับพารามิเตอร์ 2 ตัว คือ mandatory และ optionalการทำ overloding ทำให้ไม่จำเป็นต้องส่งพารามิเตอร์ทุกตัว

output :

Mandatory: Hello
Mandatory: Hello, Optional: World

2.การใช้ Vararge

ช่วยให้สามารถประกาศเมธอดที่รองรับอาร์กิวเมนต์ 0 หรือมากกว่าของประเภทที่ระบุได้ โดยการใช้จุดไข่ปลา ... ก่อนการประกาศพารามิเตอร์

public class Example {
    public void display(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }

    public static void main(String[] args) {
        Example example = new Example();
        example.display("Hello", "World", "Java");
        example.display("Single Argument");
        example.display(); // ไม่มีการส่งค่า
    }
}

บรรทัดที่ 2 : การใช้String... args ช่วยให้เมธอดสามารถรับค่าจำนวนเท่าใดก็ได้ที่เป็นชนิด String และจะถูกเก็บไว้ในอาเรย์ argsหรือไม่ส่งค่าอะไรมาเลยก็ได้ อาเรย์ args ก็จะเป็นอาเรย์ว่าง

output :

Hello
World
Java
Single Argument

🔗Parameter Optional in Python

ใน Python มี Optional Parameter ช่วยกำหนดค่าเริ่มต้นให้กับพารามิเตอร์ที่ไม่จำเป็น สามารถทำได้โดยการใช้ตัวดำเนินการกำหนดค่า หรือคำสั่ง Python **kwargs

1.ตัวอย่างการใช้ ตัวดำเนินการกำหนดค่า(Default Parameter)

def function(a, b=999):
   return a + b

print(function(2, 3))  
print(function(1))

บรรทัดที่ 1 : มีการกำหนดค่าเริ่มต้นให้กับพารามิเตอร์ b โดยตั้งค่า b = 999 ในตำแหน่งสุดท้ายของพารามิเตอร์ หากไม่มีการส่งค่ามา บรรทัดที่ 4 : คำสั่ง function(2, 3) ส่งค่าทั้ง a และ b ดังนั้นผลลัพธ์คือ 2 + 3 = 5 บรรทัดที่ 5 : คำสั่ง function(1) ส่งค่าเฉพาะ a โดยที่ b ใช้ค่าเริ่มต้น 999 ผลลัพธ์คือ 1 + 999 = 1000

output :

5
1000

2.คำสั่ง Python **kwargs

รูปแบบพิเศษ**kwargsใช้เพื่อในการส่งอาร์กิวเมนต์ที่ใช้แบบคีย์-ค่า (key-value pair) โดยใช้ชื่อkwargsพร้อมกับ ** ไว้ข้างหน้าจะทำให้ฟังก์ชันสามารถรับอาร์กิวเมนต์ได้หลายค่าพร้อมกัน โดยไม่จำเป็นต้องรู้ล่วงหน้าว่าจะส่งมากี่ค่า และสามารถระบุชื่อ (คีย์) ให้กับแต่ละค่าได้

def myFun(**kwargs):
    for key, value in kwargs.items():
        print("%s == %s" % (key, value))

myFun(first='Geeks', mid='for', last='Geeks')

บรรทัดที่ 1 : ฟังก์ชัน myFun ถูกกำหนดให้รับ kwargs ที่สามารถรับอาร์กิวเมนต์ความยาวแปรผัน บรรทัดที่ 5 : ส่งอาร์กิวเมนต์หลายตัวที่มี key (ชื่อ) และ value (ค่า) คือ first='Geeks', mid='for', และ last='Geeks'เข้าถึงได้โดยใช้ kwargs.items()