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

ฉันเป็นโปรแกรมเมอร์ C # แต่ฉันก็สงสัยว่าคนใช้คำต่างกันในภาษาที่ต่างกันหรือไม่

สำหรับบันทึกฉันเรียนรู้ด้วยตนเองโดยไม่มีพื้นฐานด้านวิทยาศาสตร์คอมพิวเตอร์ (โปรดอย่าบอกให้ฉันอ่านCode Completeเพราะฉันขอสิ่งนี้เพื่อประโยชน์ของคนอื่นที่ยังไม่มีหนังสือมหัศจรรย์ของSteve McConnell )

สรุป

ฉันทามติทั่วไปน่าจะเป็นที่ตกลงที่จะใช้คำเหล่านี้สลับกันได้ในสภาพแวดล้อมของทีม ยกเว้นบางทีเมื่อคุณนิยามคำศัพท์ที่แม่นยำ จากนั้นคุณยังสามารถใช้ " อาร์กิวเมนต์อย่างเป็นทางการ / พารามิเตอร์" และ " อาร์กิวเมนต์จริง / พารามิเตอร์" เพื่อทำให้เข้าใจผิด

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

public void MyMethod(string myParam) { }

...

string myArg1 = "this is my argument";
myClass.MyMethod(myArg1);

พารามิเตอร์เป็นตัวแปรในการประกาศฟังก์ชัน

อาร์กิวเมนต์คือมูลค่าที่แท้จริงของตัวแปรนี้ที่ส่งผ่านไปยังฟังก์ชัน

มีอยู่แล้วรายการวิกิพีเดียในเรื่อง (ดูParameter ) ที่กำหนดและแตกต่างแง่พารามิเตอร์และการโต้แย้ง กล่าวโดยย่อพารามิเตอร์เป็นส่วนหนึ่งของลายเซ็นฟังก์ชัน / ขั้นตอน / วิธีการและอาร์กิวเมนต์เป็นค่าจริงที่ให้มา ณ รันไทม์และ / หรือ call-site สำหรับพารามิเตอร์

บทความ Wikipedia ยังระบุด้วยว่าคำสองคำนี้มักจะใช้คำเหมือนกัน (โดยเฉพาะอย่างยิ่งเมื่อให้เหตุผลเกี่ยวกับโค้ดอย่างไม่เป็นทางการ):

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

รับฟังก์ชั่นตัวอย่างต่อไปนี้ใน C ที่เพิ่มจำนวนเต็มสองจำนวนxและyจะเรียกว่าเป็นพารามิเตอร์:

int add(int x, int y) {
    return x + y;
}

ที่ไซต์การโทรที่ใช้addเช่นตัวอย่างที่แสดงด้านล่าง123และ456จะถูกเรียกว่าอาร์กิวเมนต์ของการโทร

int result = add(123, 456);

นอกจากนี้ข้อกำหนดทางภาษาบางอย่าง (หรือเอกสารที่เป็นทางการ) เลือกที่จะใช้พารามิเตอร์หรืออาร์กิวเมนต์เฉพาะและใช้คำคุณศัพท์เช่นแบบเป็นทางการและเป็นจริงแทนเพื่อทำให้เข้าใจผิดระหว่างสองกรณี ยกตัวอย่างเช่นเอกสาร C / C ++ มักจะหมายถึงฟังก์ชั่นพารามิเตอร์เป็นข้อโต้แย้งที่เป็นทางการและฟังก์ชั่นการโทรการขัดแย้งเป็นข้อโต้แย้งที่เกิดขึ้นจริง ยกตัวอย่างให้ดู“ อย่างเป็นทางการและที่เป็นจริงข้อโต้แย้ง ” ในVisual C ++ ภาษาอ้างอิง

ง่าย:

• P ARAMETER → P LACEHOLDER (ซึ่งหมายความว่าตัวยึดตำแหน่งเป็นของการตั้งชื่อฟังก์ชั่นและใช้ในร่างกายของฟังก์ชั่น)
• A RGUMENT → A ค่า CTUAL (ซึ่งหมายถึงค่าจริงซึ่งถูกส่งผ่านโดยการเรียกฟังก์ชัน)

พารามิเตอร์คือสิ่งที่คุณต้องกรอกเมื่อคุณเรียกใช้ฟังก์ชัน สิ่งที่คุณใส่เข้าไปคือการโต้เถียง

ตั้งค่าง่ายๆ: อาร์กิวเมนต์เข้าสู่พารามิเตอร์อาร์กิวเมนต์คือค่าของพารามิเตอร์

ข้อมูลเพิ่มเติมอีกเล็กน้อยเกี่ยวกับ: http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments

พารามิเตอร์เป็นตัวแปรในการประกาศฟังก์ชัน

อาร์กิวเมนต์คือมูลค่าที่แท้จริงของตัวแปรนี้ที่ส่งผ่านไปยังฟังก์ชัน

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

MCSD Cerfification Toolkit (สอบ 70-483) การเขียนโปรแกรมใน C # , รุ่นที่ 1, Wrox, 2013

สถานการณ์กรณีจริงในโลก

// Define a method with two parameters
int Sum(int num1, int num2)
{
   return num1 + num2;
}

// Call the method using two arguments
var ret = Sum(2, 3);

ในการแก้ไขฉันมักจะออกไปในวิธีที่คนลืม: ภาษาโครงสร้างขึ้นอยู่กับภาษาธรรมชาติ

เป็นภาษาอังกฤษ

"พารามิเตอร์" เป็นตัวยึดตำแหน่ง พวกเขาตั้งค่ารูปแบบการตอบกลับเป็นภาษาพูด ตามคำจำกัดความมันเป็นสายของฝ่ายที่ จำกัด การตอบสนอง

"อาร์กิวเมนต์" คือตำแหน่งที่กำลังพิจารณา คุณโต้แย้งความคิดเห็นของคุณ: คุณพิจารณาข้อโต้แย้ง

ความแตกต่างหลัก

บทบาทเฉพาะเรื่องของการโต้แย้งคือตัวแทน บทบาทเฉพาะเรื่องของพารามิเตอร์คือผู้รับ

การติดต่อ

คิดว่าการโต้แย้งเป็นส่วนชายทำให้พารามิเตอร์ส่วนหญิง อาร์กิวเมนต์ไปที่พารามิเตอร์

การใช้

โดยปกติจะใช้พารามิเตอร์ในคำจำกัดความ อาร์กิวเมนต์มักใช้ในการเรียกใช้

คำถาม

จบประโยคเพื่อให้ไม่สอดคล้องกัน

(A) การพูดของคำจำกัดความ:

1. จะใช้อาร์กิวเมนต์อะไร []?
2. พารามิเตอร์นี้จะ [อะไร] [?

(B) การพูดถึงการร้องขอ:

1. คุณจะใช้พารามิเตอร์ใด []?
2. [] จะเป็นอะไร [] พารามิเตอร์นี้?

คำตอบ

(A)

1. เปิด / ใน / กับ / ด้วยพารามิเตอร์นี้
2. การโต้เถียง ...

(B)

1. และอะไรคือตัวอย่างของข้อโต้แย้ง
2. อาร์กิวเมนต์ ... ใช้ใน / ใน / กับ / กับ

การทับซ้อน

อย่างที่คุณสามารถจินตนาการได้หลังจากตอบ: เป็นภาษาพูดบางครั้งคำเหล่านี้จะให้คำตอบที่เหมือนกัน!

ดังนั้นตามกฎ:

• โดยปกติถ้ามีคนต้องการข้อมูลพารามิเตอร์พวกเขาต้องการทราบเพิ่มเติมเกี่ยวกับประเภทชื่อตัวแปร ฯลฯ พวกเขาอาจสับสนหากคุณให้ตัวอย่างอาร์กิวเมนต์เท่านั้น

  • โดยปกติถ้ามีคนต้องการข้อมูลอาร์กิวเมนต์พวกเขาต้องการทราบว่าคุณส่งผ่านค่าใดไปยังฟังก์ชันหรือพารามิเตอร์ของมัน

ตัวอย่างนี้อาจช่วยได้

int main () {
   int x = 5; 
   int y = 4;

   sum(x, y); // **x and y are arguments**
}

int sum(int one, int two) { // **one and two are parameters**
   return one + two;
}

โปรดจำไว้เสมอว่า: - อาร์กิวเมนต์จะถูกส่งผ่านในขณะที่รับพารามิเตอร์

พารามิเตอร์ของฟังก์ชัน / วิธีการอธิบายให้คุณค่าที่จะใช้ในการคำนวณผลของมัน

ข้อโต้แย้งของฟังก์ชั่นนี้เป็นค่าที่กำหนดให้กับพารามิเตอร์เหล่านี้ในระหว่างการเรียกร้องโดยเฉพาะอย่างยิ่งของฟังก์ชั่น / วิธีการ

หรืออาจจะง่ายกว่าที่จะจำเช่นนี้ในกรณีที่มีข้อโต้แย้งเพิ่มเติมสำหรับวิธีการ:

public void Method(string parameter = "argument") 
{

}

parameterคือพารามิเตอร์ค่าของมัน"argument"คืออาร์กิวเมนต์ :)

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

เครื่องบินเป็นหน้าที่ของคุณ

พารามิเตอร์คือที่นั่ง

ข้อโต้แย้งคือผู้โดยสารที่นั่งในที่นั่งเหล่านั้น

พารามิเตอร์และอาร์กิวเมนต์

คำศัพท์ต่าง ๆ ที่เกี่ยวข้องกับพารามิเตอร์และอาร์กิวเมนต์อาจทำให้สับสนได้ อย่างไรก็ตามหากคุณคำนึงถึงจุดง่าย ๆ สองสามข้อคุณจะสามารถจัดการข้อกำหนดเหล่านี้ได้อย่างง่ายดาย

1. พารามิเตอร์อย่างเป็นทางการสำหรับฟังก์ชั่นมีการระบุไว้ในการประกาศฟังก์ชั่นและมีการใช้ในร่างกายของคำนิยามฟังก์ชัน พารามิเตอร์ทางการ (ของการเรียงลำดับใด ๆ ) เป็นประเภทของว่างเปล่าหรือตัวยึดที่เต็มไปด้วยบางสิ่งบางอย่างเมื่อมีการเรียกใช้ฟังก์ชั่น
2. อาร์กิวเมนต์คือสิ่งที่จะใช้ในการกรอกข้อมูลในพารามิเตอร์อย่างเป็นทางการ เมื่อคุณจดการเรียกใช้ฟังก์ชันอาร์กิวเมนต์จะแสดงรายการในวงเล็บหลังชื่อฟังก์ชัน เมื่อมีการดำเนินการเรียกใช้ฟังก์ชันอาร์กิวเมนต์จะถูกเสียบเข้ากับพารามิเตอร์ที่เป็นทางการ
3. คำว่า call-by-valueและcall-by-referenceอ้างถึงกลไกที่ใช้ในกระบวนการเสียบปลั๊ก ในเมธอด call-by-value จะใช้ค่าของอาร์กิวเมนต์เท่านั้น ในกลไก call-by-value นี้พารามิเตอร์ formal เป็นตัวแปรโลคัลที่ถูกกำหนดค่าเริ่มต้นให้กับค่าของอาร์กิวเมนต์ที่สอดคล้องกัน ในกลไกการโทรโดยการอ้างอิงอาร์กิวเมนต์เป็นตัวแปรและใช้ตัวแปรทั้งหมด ในกลไกการโทร - โดย - อ้างอิงตัวแปรอาร์กิวเมนต์จะถูกแทนที่สำหรับพารามิเตอร์ที่เป็นทางการเพื่อให้การเปลี่ยนแปลงใด ๆ ที่ทำกับพารามิเตอร์ที่เป็นทางการจะทำจริงกับตัวแปรอาร์กิวเมนต์

ที่มา: Absolute C ++, Walter Savitch

นั่นคือ,

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

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

อาร์กิวเมนต์คือการสร้างอินสแตนซ์ของพารามิเตอร์

ใช่ พารามิเตอร์และอาร์กิวเมนต์มีความหมายต่างกันซึ่งสามารถอธิบายได้ง่าย ๆ ดังนี้:

ฟังก์ชั่นพารามิเตอร์เป็นชื่อที่ระบุไว้ในคำนิยามฟังก์ชั่น

อาร์กิวเมนต์ของฟังก์ชันคือค่าจริงที่ส่งผ่านไปยัง (และรับโดย) ฟังก์ชัน

คำอธิบายอย่างง่ายโดยไม่ต้องใช้รหัส

"พารามิเตอร์" เป็นสิ่งทั่วไปกว้าง ๆ แต่อาร์กิวเมนต์ ": เป็นสิ่งที่เฉพาะเจาะจงมากและเป็นรูปธรรมนี่คือตัวอย่างที่ดีที่สุดผ่านตัวอย่างประจำวัน:

ตัวอย่างที่ 1: ตู้ขายสินค้าอัตโนมัติ - เงินคือพารามิเตอร์ $ 2.00 เป็นอาร์กิวเมนต์

เครื่องส่วนใหญ่รับอินพุตและส่งคืนเอาต์พุต ตัวอย่างเช่นเครื่องหยอดเหรียญใช้เป็นอินพุต: เงินและผลตอบแทน: เครื่องดื่มเป็นฟองเอาท์พุท ในกรณีเฉพาะนั้นยอมรับเป็นพารามิเตอร์: money

อะไรคือข้อโต้แย้ง ถ้าฉันใส่ $ 2.00 ลงในเครื่องอาร์กิวเมนต์ก็คือ: $ 2.00 - มันเป็นอินพุตที่เจาะจงมากที่ใช้

ตัวอย่างที่ 2: รถยนต์ - น้ำมันเป็นพารามิเตอร์

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

ตัวอย่างที่ 3 - การทำข้อโต้แย้งอย่างถี่ถ้วน

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

อะไรคือข้อโต้แย้ง การโต้เถียงจะเป็นคนที่ถูกใส่เข้าไปในเครื่อง เช่นถ้าใส่ Colin Powell ลงไปในเครื่องแล้วอาร์กิวเมนต์ก็จะเป็น Colin Powell

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

นั่นคือความแตกต่าง ง่าย

สับสน?

โพสต์ความคิดเห็นและฉันจะแก้ไขคำอธิบาย

หรือง่ายกว่า ...

มีข้อโต้แย้งใน!

พารามิเตอร์ออกมา!

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

int main ()
{
   /* local variable definition */
   int a = 100;
   int b = 200;
   int ret;

   /* calling a function to get max value */
   ret = max(a, b);

   printf( "Max value is : %d\n", ret );

   return 0;
}

/* function returning the max between two numbers */
int max(int num1, int num2) 
{
   /* local variable declaration */
   int result;

   if (num1 > num2)
      result = num1;
   else
      result = num2;

   return result; 
}

ในรหัสข้างต้นnum1และnum2เป็นพารามิเตอร์ที่เป็นทางการและaและbมีข้อโต้แย้งที่เกิดขึ้นจริง

บทเรียน Java ของ Oracle กำหนดความแตกต่างดังนี้: "พารามิเตอร์หมายถึงรายการตัวแปรในการประกาศเมธอดอาร์กิวเมนต์คือค่าจริงที่ส่งผ่านเมื่อเมธอดถูกเรียกใช้เมื่อคุณเรียกใช้เมธอดอาร์กิวเมนต์ที่ใช้ต้องตรงกับพารามิเตอร์ของการประกาศ ในประเภทและการสั่งซื้อ "

การอภิปรายรายละเอียดเพิ่มเติมเกี่ยวกับพารามิเตอร์และอาร์กิวเมนต์: https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html

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

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

พารามิเตอร์คือซ็อกเก็ตของปลั๊กอินซึ่งอาจมีรูปร่างที่แตกต่างหลากหลาย แต่มีปลั๊กบางชนิดเท่านั้นที่พอดีกับมัน
อาร์กิวเมนต์จะเป็นปลั๊กจริงที่จะเสียบเข้ากับจุดเสียบ / ซ็อกเก็ตเพื่อเปิดใช้งานอุปกรณ์บางอย่าง

พารามิเตอร์เป็นตัวแปรในนิยามฟังก์ชัน
อาร์กิวเมนต์คือค่าของพารามิเตอร์

<?php

    /* define function */
    function myFunction($parameter1, $parameter2)
    {
        echo "This is value of paramater 1: {$parameter1} <br />";
        echo "This is value of paramater 2: {$parameter2} <br />";
    }

    /* call function with arguments*/
    myFunction(1, 2);

?>

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

แต่จากมุมมองของฟังก์ชั่น:

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

เมื่อเราสร้างวิธีการ (ฟังก์ชั่น) ใน Java วิธีการเช่นนี้ ..

data-type name of the method (data-type variable-name)

ในวงเล็บนี่คือพารามิเตอร์และเมื่อเราเรียกเมธอด (ฟังก์ชัน) เราจะส่งค่าของพารามิเตอร์นี้ซึ่งเรียกว่าอาร์กิวเมนต์

อ้างอิงจากหนังสือ Alabahari ของโจเซฟ "C # in the nutshell" (C # 7.0, p. 49):

static void Foo (int x)
{
    x = x + 1; // When you're talking in context of this method x is parameter
    Console.WriteLine (x);
}
static void Main()
{
    Foo (8); // an argument of 8. 
             // When you're talking from the outer scope point of view
}

ในภาษามนุษย์บางคำ (afaik อิตาลี, รัสเซีย) มีการใช้คำพ้องความหมายอย่างกว้างขวางสำหรับคำเหล่านี้

• พารามิเตอร์ = พารามิเตอร์ที่เป็นทางการ
• อาร์กิวเมนต์ = พารามิเตอร์จริง

ในมหาวิทยาลัยอาจารย์ของฉันใช้ชื่อทั้งสองชนิด

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

พารามิเตอร์ที่เป็นทางการสำหรับฟังก์ชั่นมีการระบุไว้ในการประกาศฟังก์ชั่นและมีการใช้ในร่างกายของคำนิยามฟังก์ชั่น พารามิเตอร์ทางการ(ของการเรียงลำดับใด ๆ ) เป็นประเภทของว่างเปล่าหรือตัวยึดที่เต็มไปด้วยบางสิ่งบางอย่างเมื่อมีการเรียกใช้ฟังก์ชั่น

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

คำว่า call-by-valueและcall-by-referenceอ้างถึงกลไกที่ใช้ในกระบวนการเสียบปลั๊ก ในเมธอด call-by-value จะใช้ค่าของอาร์กิวเมนต์เท่านั้น ในกลไก call-by-value นี้พารามิเตอร์ formal เป็นตัวแปรโลคัลที่ถูกกำหนดค่าเริ่มต้นให้กับค่าของอาร์กิวเมนต์ที่สอดคล้องกัน ในกลไกการโทรโดยการอ้างอิงอาร์กิวเมนต์เป็นตัวแปรและใช้ตัวแปรทั้งหมด ในกลไกการโทร - โดย - อ้างอิงตัวแปรอาร์กิวเมนต์จะถูกแทนที่สำหรับพารามิเตอร์ที่เป็นทางการเพื่อให้การเปลี่ยนแปลงใด ๆ ที่ทำกับพารามิเตอร์ที่เป็นทางการจะทำจริงกับตัวแปรอาร์กิวเมนต์

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

// x and y are parameters in this function declaration
function add(x, y) {
  // function body
  var sum = x + y;
  return sum; // return statement
}

// 1 and 2 are passed into the function as arguments
var sum = add(1, 2);

ฉันคิดว่ามันผ่านและตระหนักว่าคำตอบก่อนหน้าของฉันผิด นี่คือคำนิยามที่ดีกว่ามาก

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

แม่บ้านเป็นวิธีการ

(คุณต้อง __call_ หรือถามวิธีนี้เพื่อทำอาหารเช้า) (การทำอาหารเช้าเป็นฟังก์ชั่นที่เรียกว่าการทำอาหาร ) _

ไข่และไส้กรอกเป็นพารามิเตอร์:

(เพราะจำนวนไข่และจำนวนไส้กรอกที่คุณต้องการกินคือ __variable_.) _

การตัดสินใจของคุณคือการโต้แย้ง:

มันหมายถึง __ ค่า _ ของจำนวนไข่และ / หรือไส้กรอกที่คุณเลือกทำอาหาร.

{ Mnemonic }

_ "เมื่อคุณโทรหาแม่บ้านและขอให้เธอทำอาหารเช้าเธอ __argues_ กับคุณเกี่ยวกับจำนวนไข่และไส้กรอกที่คุณควรกินเธอกังวลเกี่ยวกับคอเลสเตอรอลของคุณ" __

(อาร์กิวเมนต์คือค่าสำหรับการรวมกันของพารามิเตอร์ที่คุณประกาศและตัดสินใจที่จะส่งผ่านไปยังฟังก์ชันของคุณ)