2nd/10_Wiki/Topic_JavaScript/JavaScript_Function_Arguments.md

id, title, category, status, verification_status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, created_at, updated_at, review_reason, merge_history, tags, raw_sources, applied_in, github_commit

id	title	category	status	verification_status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	created_at	updated_at	review_reason	merge_history	tags	raw_sources	applied_in	github_commit
javascript-function-arguments	JavaScript Function Arguments	Frontend	draft	conceptual		JS function arguments function parameters arguments object default parameters rest parameter pass by value pass by reference		B	0.89	2026-06-23	2026-06-23			javascript js web frontend w3schools functions arguments parameters	https://www.w3schools.com/js/js_function_arguments.asp

JavaScript Function Arguments

🎯 한 줄 통찰 (One-line insight)

Parameters are the names listed in a function definition; arguments are the real values passed in — and JavaScript never checks their type or count, so missing arguments become undefined. [S1]

🧠 핵심 개념 (Core concepts)

• Parameters vs. arguments — parameters are the names in the function definition; arguments are the real values passed to and received by the function. [S1]
• Order matters — arguments are assigned to parameters in the order they appear. [S1]
• No type or count checking — JavaScript function definitions do not specify data types, do not perform type checking, and do not check the number of arguments received. [S1]
• Missing arguments become undefined — calling with fewer arguments than parameters leaves the missing ones undefined. [S1]
• arguments object — every function has a built-in arguments object containing an array of the arguments used at call time, reachable even when more arguments are passed than declared. [S1]
• Pass by value vs. reference — primitives are passed by value (changes are not reflected outside); objects behave like they are passed by reference (changing an object property changes the original). [S1]

🧩 추출된 패턴 (Extracted patterns)

• Variadic via arguments — loop over arguments.length to handle an indefinite number of inputs without declaring parameters. [S1]
• Default parameter guard — set a default with y = 10 in the signature (ES2015), or the older if (y === undefined) y = 2; pattern. [S1]
• Rest parameter collection — ...args gathers an indefinite number of arguments into a real array for iteration with for...of. [S1]

📖 세부 내용 (Details)

Parameters vs. Arguments Function parameters are the names listed in the function definition. Arguments are the real values passed to, and received by, the function. [S1]

function multiply(a, b) {
  return a * b;
}

let result = multiply(4, 5);

Here a and b are parameters; 4 and 5 are arguments. The argument 4 is assigned to parameter a and 5 to parameter b. [S1]

The Arguments Object JavaScript functions have a built-in arguments object that contains an array of the arguments used when the function was invoked. This lets a function find, for instance, the highest value in a list of numbers: [S1]

x = findMax(1, 123, 500, 115, 44, 88);

function findMax() {
  let max = -Infinity;
  for (let i = 0; i < arguments.length; i++) {
    if (arguments[i] > max) {
      max = arguments[i];
    }
  }
  return max;
}

Or sum all input values: [S1]

x = sumAll(1, 123, 500, 115, 44, 88);

function sumAll() {
  let sum = 0;
  for (let i = 0; i < arguments.length; i++) {
    sum += arguments[i];
  }
  return sum;
}

If a function is called with too many arguments (more than declared), those arguments can still be reached using the arguments object. [S1]

The Order of Arguments Matters Arguments are assigned to parameters in the order they appear. [S1]

function subtract(a, b) {
  return a - b;
}

let x1 = subtract(10, 5);
let x2 = subtract(5, 10);

The two calls return different results because the order is different. [S1]

Arguments Can Be Variables Arguments do not have to be values; they can also be variables. [S1]

let x = 5;
let y = 6;

function multiply(a, b) {
  return a * b;
}

multiply(x, y);

Argument Rules JavaScript function definitions do not specify data types for arguments. JavaScript functions do not perform type checking on the passed arguments. JavaScript functions do not check the number of arguments received. [S1]

Incorrect Arguments Incorrect arguments can return incorrect answers: [S1]

function toCelsius(fahrenheit) {
  return (5/9) * (fahrenheit-32);
}

let value = toCelsius("John");

Missing Arguments If a function is called with fewer arguments than parameters, the missing values become undefined. [S1]

function multiply(a, b) {
  return a * b;
}

multiply(4);

Here b is undefined, so the result is NaN. A JavaScript function does not perform any checking on parameter values. [S1]

Default Parameters If a function is called with missing arguments, the missing values are set to undefined. Sometimes it is better to assign a default value to the parameter: [S1]

function myFunction(x, y) {
  if (y === undefined) {
    y = 2;
  }
}

Default Parameter Values ECMAScript 2015 allows function parameters to have default values. The default value is used if no argument is provided. If y is not passed or undefined, then y = 10: [S1]

function myFunction(x, y = 10) {
  return x + y;
}
myFunction(5);

Function Rest Parameter The rest parameter (...) allows a function to treat an indefinite number of arguments as an array: [S1]

function sum(...args) {
  let sum = 0;
  for (let arg of args) sum += arg;
  return sum;
}

let x = sum(4, 9, 16, 25, 29, 100, 66, 77);

Arguments are Passed by Value The parameters in a function call are the function's arguments. JavaScript arguments are passed by value: the function only gets to know the values, not the argument's locations. If a function changes an argument's value, it does not change the parameter's original value. Changes to arguments are not visible (reflected) outside the function. [S1]

Objects are Passed by Reference In JavaScript, object references are values. Because of this, objects will behave like they are passed by reference: if a function changes an object property, it changes the original value. Changes to object properties are visible (reflected) outside the function. [S1]

Common Mistakes Confusing parameters and arguments (parameters are names, arguments are values); forgetting the order (arguments are assigned by position); missing arguments (use default values to avoid undefined). [S1]

🛠️ 적용 사례 (Applied in summary)

The page's own snippets are the canonical applied examples — multiply/subtract for parameter binding, findMax/sumAll for the arguments object, and sum(...args) for the rest parameter. No external project/commit applications found in the source.

💻 코드 패턴 (Code patterns)

Default parameter value (ES2015):

function myFunction(x, y = 10) {
  return x + y;
}

Variadic via rest parameter:

function sum(...args) {
  let sum = 0;
  for (let arg of args) sum += arg;
  return sum;
}

Variadic via the arguments object:

function sumAll() {
  let sum = 0;
  for (let i = 0; i < arguments.length; i++) {
    sum += arguments[i];
  }
  return sum;
}

⚖️ 모순 및 업데이트 (Contradictions & updates)

No contradictions found in the source. The page notes a version distinction: default parameter values are an ECMAScript 2015 feature, contrasted with the older if (y === undefined) guard pattern. [S1]

✅ 검증 상태 및 신뢰도

• 상태: draft
• 검증 단계: conceptual (실제 적용 사례 발견 시 applied/validated로 승격 가능)
• 출처 신뢰도: B (W3Schools — widely used educational reference, not a primary standards body)
• 신뢰 점수: 0.89
• 중복 검사 결과: 신규 생성 (New discovery)

🔗 지식 그래프 (Knowledge Graph)

• 상위/루트: JavaScript Tutorial
• 관련 개념: JavaScript Function Expressions, JavaScript Arrow Functions, JavaScript Objects
• 참조 맥락: Referenced whenever defining functions and reasoning about how values reach them, including variadic functions and defaults.

📚 출처 (Sources)

• [S1] W3Schools — JavaScript Function Arguments — https://www.w3schools.com/js/js_function_arguments.asp

📝 변경 이력 (Change history)

• 2026-06-23: Initial draft synthesized from the W3Schools "JavaScript Function Arguments" page (Astra wiki-curation, P-Reinforce v3.1 format).