[{"data":1,"prerenderedAt":174},["ShallowReactive",2],{"qa-\u002Fjavascript\u002Ffunctions\u002Ffunction-types-parameters":3},{"page":4,"siblings":154,"blog":171},{"id":5,"title":6,"body":7,"description":11,"difficulty":14,"extension":15,"framework":16,"frameworkSlug":17,"meta":18,"navigation":19,"order":20,"path":21,"questions":22,"related":145,"seo":146,"seoDescription":147,"stem":148,"subtopic":149,"topic":150,"topicSlug":151,"updated":152,"__hash__":153},"qa\u002Fjavascript\u002Ffunctions\u002Ffunction-types-parameters.md","Function Types Parameters",{"type":8,"value":9,"toc":10},"minimark",[],{"title":11,"searchDepth":12,"depth":12,"links":13},"",2,[],"medium","md","JavaScript","javascript",{},true,4,"\u002Fjavascript\u002Ffunctions\u002Ffunction-types-parameters",[23,28,32,36,40,44,48,53,57,61,65,69,73,77,81,85,89,93,97,101,105,109,113,117,121,125,129,133,137,141],{"id":24,"difficulty":25,"q":26,"a":27},"declaration-vs-expression","easy","What is the difference between a function declaration and a function expression?","A **function declaration** stands alone as a statement and is **hoisted**\nwhole, so you can call it before its line. A **function expression** assigns a\nfunction to a variable; only the variable is hoisted, not its value.\n\n```js\nsayHi()                       \u002F\u002F works — declaration hoisted\nfunction sayHi() {}\n\nsayBye()                      \u002F\u002F TypeError: sayBye is not a function\nvar sayBye = function () {}   \u002F\u002F expression — value assigned at runtime\n```\n\n**Pitfall:** with `let`\u002F`const` the expression variable is in the temporal\ndead zone, so calling early throws a ReferenceError instead. Choose\ndeclarations for top-level reusable functions and expressions when passing a\nfunction as a value.\n",{"id":29,"difficulty":25,"q":30,"a":31},"named-vs-anonymous","What is the difference between named and anonymous functions?","A **named function** has its own identifier; an **anonymous function** has\nnone. The name aids **recursion** and **stack traces**.\n\n```js\nconst fac = function factorial(n) {           \u002F\u002F named function expression\n  return n \u003C= 1 ? 1 : n * factorial(n - 1)    \u002F\u002F can call itself by name\n}\n\n[1].map(function () {})    \u002F\u002F anonymous — appears unnamed in traces\n```\n\nModern engines infer a name for anonymous functions assigned to a variable, so\n`const f = () => {}` has `f.name === 'f'`. **Pitfall:** a named function\nexpression's inner name is only visible **inside** the function, not outside.\n",{"id":33,"difficulty":14,"q":34,"a":35},"arrow-vs-regular","How do arrow functions differ from regular functions?","Arrow functions are more than shorter syntax. They have **no own `this`,\n`arguments`, `super`, or `new.target`** — they inherit `this` lexically — and\nthey **cannot be used as constructors**.\n\n```js\nconst obj = {\n  items: [1, 2],\n  log() {\n    this.items.forEach(i => console.log(this.items))  \u002F\u002F `this` is obj\n  }\n}\nconst Arrow = () => {}\nnew Arrow()   \u002F\u002F TypeError: Arrow is not a constructor\n```\n\n**Pitfall:** don't use an arrow as an object **method** if you need `this` to\nbe the object — it will be the surrounding scope's `this` (often the module or\nwindow), not the object.\n",{"id":37,"difficulty":14,"q":38,"a":39},"what-is-iife","What is an IIFE and why use one?","An **IIFE (Immediately Invoked Function Expression)** is a function defined and\ncalled at once. It creates a **private scope** so its variables don't leak.\n\n```js\n(function () {\n  const secret = 42        \u002F\u002F not visible outside\n  console.log(secret)\n})()                       \u002F\u002F runs immediately\n\n\u002F\u002F arrow form\n(() => { \u002F* ... *\u002F })()\n```\n\nThe wrapping parens turn the declaration into an **expression** so it can be\ninvoked. IIFEs powered the old **module pattern** before ES modules. **Pitfall:**\na missing semicolon before an IIFE can make the previous line try to call it —\ndefensively prefix with `;`.\n",{"id":41,"difficulty":25,"q":42,"a":43},"first-class-functions","What does it mean that functions are first-class in JavaScript?","**First-class** means functions are treated like any other **value**: they can\nbe assigned to variables, stored in arrays\u002Fobjects, passed as arguments, and\nreturned from functions.\n\n```js\nconst ops = { add: (a, b) => a + b }   \u002F\u002F stored in an object\nconst fns = [Math.abs, Math.sqrt]      \u002F\u002F stored in an array\nconst run = fn => fn(16)               \u002F\u002F passed as argument\nrun(fns[1])   \u002F\u002F 4\n```\n\nThis is the foundation that makes **higher-order functions, callbacks, and\nclosures** possible. Without first-class functions, none of the functional\npatterns in JS would work.\n",{"id":45,"difficulty":25,"q":46,"a":47},"default-parameters","How do default parameters work?","A **default parameter** supplies a value when the argument is **`undefined`**\n(either omitted or explicitly `undefined`). The default expression is\nevaluated **at call time**, only when needed.\n\n```js\nfunction greet(name = 'friend') { return `Hi, ${name}` }\ngreet()           \u002F\u002F 'Hi, friend'\ngreet(undefined)  \u002F\u002F 'Hi, friend'   — default applies\ngreet(null)       \u002F\u002F 'Hi, null'     null is NOT undefined\n```\n\n**Pitfall:** only `undefined` triggers the default — passing `null`, `0`, or\n`''` does not. Defaults can also reference **earlier parameters**:\n`(a, b = a * 2) => ...`.\n",{"id":49,"difficulty":50,"q":51,"a":52},"defaults-evaluation-order","hard","When are default parameter expressions evaluated, and in what order?","Defaults are evaluated **left to right at call time**, each in a scope where\n**earlier parameters are already bound** but later ones are not. They are fresh\nevery call, not cached.\n\n```js\nlet calls = 0\nconst next = () => ++calls\nfunction f(a = next(), b = a + 1) { return [a, b] }\nf()      \u002F\u002F [1, 2]   — next() ran once, b saw a\nf(10)    \u002F\u002F [10, 11] — default for a skipped, next() not called\n```\n\n**Pitfall:** referencing a **later** parameter in an earlier default throws a\nReferenceError (TDZ): `function g(a = b, b = 1) {}` — `g()`. Also, an object\ndefault like `{ items: [] }` creates a **new array each call**, avoiding the\nshared-mutable-default trap seen in some other languages.\n",{"id":54,"difficulty":14,"q":55,"a":56},"rest-parameters","What are rest parameters?","A **rest parameter** (`...args`) collects all remaining arguments into a\n**real array**. It must be the **last** parameter and there can be only one.\n\n```js\nfunction sum(...nums) {\n  return nums.reduce((a, b) => a + b, 0)   \u002F\u002F nums is a true array\n}\nsum(1, 2, 3)   \u002F\u002F 6\n\nfunction tagged(first, ...rest) { \u002F* first separate, rest gathers the tail *\u002F }\n```\n\nUnlike the old `arguments` object, rest params are a genuine `Array` (with\n`map`, `filter`, etc.). **Pitfall:** rest params are **excluded** from\n`fn.length` (arity).\n",{"id":58,"difficulty":14,"q":59,"a":60},"arguments-object","What is the arguments object?","`arguments` is an **array-like** object available inside **regular** (non-arrow)\nfunctions, holding **all** passed arguments regardless of declared parameters.\n\n```js\nfunction f() {\n  return arguments.length          \u002F\u002F works even with no named params\n}\nf(1, 2, 3)   \u002F\u002F 3\n\n\u002F\u002F it's array-LIKE, not an array\nArray.prototype.slice.call(arguments)   \u002F\u002F convert to real array\n[...arguments]                          \u002F\u002F modern conversion\n```\n\n**Pitfall:** it lacks array methods (`map`, `forEach`), so convert it first.\nIn modern code, prefer **rest parameters** over `arguments`.\n",{"id":62,"difficulty":14,"q":63,"a":64},"why-arrows-no-arguments","Why don't arrow functions have their own arguments object?","Arrow functions deliberately have **no own `arguments`** — like `this`, they\ninherit it lexically from the enclosing **regular** function (or it's\nundefined at module top level).\n\n```js\nfunction outer() {\n  const inner = () => arguments[0]   \u002F\u002F refers to outer's arguments\n  return inner()\n}\nouter('hi')   \u002F\u002F 'hi'\n\nconst f = () => arguments   \u002F\u002F ReferenceError at top level\n```\n\nThe fix when you need all args in an arrow is **rest parameters**:\n`const f = (...args) => args`. This lexical behavior is exactly why arrows are\ngreat as callbacks but unsuitable as methods needing their own `arguments`.\n",{"id":66,"difficulty":14,"q":67,"a":68},"function-length","What does a function's length property return?","`fn.length` is the function's **arity** — the number of parameters **before**\nthe first one with a default value or a rest parameter. It does **not** count\nthose.\n\n```js\n((a, b) => {}).length        \u002F\u002F 2\n((a, b = 1) => {}).length    \u002F\u002F 1   — stops at first default\n((a, ...rest) => {}).length  \u002F\u002F 1   — rest excluded\n((a, b, c = 1, d) => {}).length \u002F\u002F 2 — counts up to first default\n```\n\n**Pitfall:** because defaults and rest reduce `length`, generic helpers like\n`curry` that rely on `fn.length` misbehave on such functions. `length` is\nread-only.\n",{"id":70,"difficulty":25,"q":71,"a":72},"function-name","How is a function's name property determined?","`fn.name` is the function's name string, used in **stack traces** and\ndebugging. Engines **infer** it from the variable or property a function is\nassigned to when the function itself is anonymous.\n\n```js\nfunction foo() {}\nfoo.name                 \u002F\u002F 'foo'\nconst bar = () => {}\nbar.name                 \u002F\u002F 'bar'    — inferred\nconst o = { baz() {} }\no.baz.name               \u002F\u002F 'baz'\n[].map(() => {}).name    \u002F\u002F '' or anonymous — not assigned to a binding\n```\n\n`bind` prepends `'bound '`: `foo.bind(null).name === 'bound foo'`. **Pitfall:**\nminifiers rename functions, so don't rely on `name` for program logic.\n",{"id":74,"difficulty":14,"q":75,"a":76},"parameter-destructuring","How does parameter destructuring work?","You can **destructure** an object or array argument right in the parameter\nlist, pulling out the fields you need and optionally giving them defaults.\n\n```js\nfunction createUser({ name, role = 'user', age } = {}) {\n  return `${name} (${role})`\n}\ncreateUser({ name: 'Ada', role: 'admin' })   \u002F\u002F 'Ada (admin)'\ncreateUser()                                  \u002F\u002F 'undefined (user)' no crash\n```\n\nThe trailing `= {}` is crucial: it lets the function be **called with no\nargument** without throwing. **Pitfall:** omitting it and calling\n`createUser()` throws \"Cannot destructure property of undefined\".\n",{"id":78,"difficulty":25,"q":79,"a":80},"methods-vs-functions","What is the difference between a method and a function?","A **method** is simply a function stored as an **object property** and usually\ncalled with a receiver (`obj.method()`), so its `this` is that object. A plain\n**function** is called standalone and its `this` depends on call context.\n\n```js\nconst calc = {\n  value: 10,\n  double() { return this.value * 2 }   \u002F\u002F method — `this` is calc\n}\ncalc.double()   \u002F\u002F 20\n\nconst d = calc.double\nd()             \u002F\u002F `this` is undefined — now a detached function call\n```\n\n**Pitfall:** detaching a method (`const d = calc.double`) loses the receiver;\n`this` is determined by **how** it's called, not where it lives.\n",{"id":82,"difficulty":14,"q":83,"a":84},"shorthand-method","What is method shorthand and how does it differ from a property holding a function?","**Method shorthand** (`foo() {}` inside an object) is mostly equivalent to\n`foo: function () {}`, but shorthand methods can use **`super`** and are\ncreated as **non-constructable** (you can't `new` them).\n\n```js\nconst obj = {\n  greet() { return 'hi' },             \u002F\u002F shorthand\n  greet2: function () { return 'hi' }  \u002F\u002F property with function\n}\nnew obj.greet2()   \u002F\u002F works (legacy)\nnew obj.greet()    \u002F\u002F TypeError: not a constructor\n```\n\n**Pitfall:** the inability to construct shorthand methods is by design; it's\nrarely an issue but surprising if you relied on it.\n",{"id":86,"difficulty":14,"q":87,"a":88},"recursion-basics","What is recursion and what does every recursive function need?","**Recursion** is a function calling **itself** to solve a smaller version of a\nproblem. Every recursive function needs a **base case** that stops the\nrecursion and a **recursive case** that moves toward it.\n\n```js\nfunction factorial(n) {\n  if (n \u003C= 1) return 1          \u002F\u002F base case\n  return n * factorial(n - 1)   \u002F\u002F recursive case, n shrinks\n}\nfactorial(5)   \u002F\u002F 120\n```\n\n**Pitfall:** a missing or unreachable base case causes infinite recursion and\na **\"Maximum call stack size exceeded\"** error. Deep recursion can also blow\nthe stack even when correct.\n",{"id":90,"difficulty":50,"q":91,"a":92},"tail-call","What is a tail call, and does JavaScript optimize them?","A **tail call** is when a function's **last action** is to return the result of\nanother call, with nothing left to do afterward. Proper Tail Calls (PTC) would\nlet the engine **reuse the stack frame**, enabling unbounded recursion.\n\n```js\nfunction fact(n, acc = 1) {\n  if (n \u003C= 1) return acc\n  return fact(n - 1, n * acc)   \u002F\u002F tail position — no pending multiply\n}\n```\n\n**Reality:** although PTC is in the ES2015 spec, **only Safari\u002FJavaScriptCore**\nimplements it; V8 (Chrome\u002FNode) and Firefox do not. **Pitfall:** so don't rely\non tail-call elimination for deep recursion — use a loop or an explicit stack\ninstead.\n",{"id":94,"difficulty":25,"q":95,"a":96},"arity-definition","What is arity?","**Arity** is the **number of arguments a function expects** — its declared\nparameter count, reflected (with caveats) by `fn.length`.\n\n```js\nconst unary  = x => x         \u002F\u002F arity 1\nconst binary = (a, b) => a+b  \u002F\u002F arity 2\nbinary.length   \u002F\u002F 2\n```\n\nSome HOFs depend on arity — e.g. a `curry` helper invokes once enough args\narrive. **Pitfall:** \"expected\" arity (`length`) and \"actual\" args passed can\ndiffer freely in JS, since extra args are ignored and missing ones become\n`undefined`.\n",{"id":98,"difficulty":14,"q":99,"a":100},"variadic-functions","What is a variadic function?","A **variadic** function accepts a **variable number of arguments**. In modern\nJS you express this with a **rest parameter**; older code read `arguments`.\n\n```js\nconst max = (...nums) => nums.reduce((m, n) => n > m ? n : m, -Infinity)\nmax(3, 9, 2)        \u002F\u002F 9\nmax(...[5, 1, 8])   \u002F\u002F 8   — spread an array in\n\nMath.max(1, 2, 3)   \u002F\u002F built-in variadic example\n```\n\n**Pitfall:** spreading a **very large** array into a variadic call can exceed\nthe engine's argument limit and throw — use `reduce` over the array directly\nfor huge inputs.\n",{"id":102,"difficulty":14,"q":103,"a":104},"pass-by-value-reference","Are function arguments passed by value or by reference in JavaScript?","JavaScript is **pass-by-value** for everything — but for objects the \"value\"\nis a **reference** (a copy of the pointer). So you can mutate an object's\ncontents, but **reassigning** the parameter doesn't affect the caller.\n\n```js\nfunction mutate(o) { o.x = 1 }      \u002F\u002F caller sees x === 1\nfunction reassign(o) { o = { x: 9 } } \u002F\u002F caller unaffected\n\nconst a = {}; mutate(a)    \u002F\u002F a.x === 1\nconst b = {}; reassign(b)  \u002F\u002F b unchanged\n```\n\n**Pitfall:** this trips people who expect \"pass by reference\" — only the\n**reference is copied**, so reassigning the local parameter is invisible to\nthe caller.\n",{"id":106,"difficulty":25,"q":107,"a":108},"optional-arguments","What happens when you call a function with fewer or more arguments than declared?","JavaScript is **lenient about arity**. Missing arguments are `undefined`; extra\narguments are **ignored** (but still available via `arguments`\u002Frest).\n\n```js\nfunction f(a, b) { return [a, b] }\nf(1)         \u002F\u002F [1, undefined]   — missing -> undefined\nf(1, 2, 3)   \u002F\u002F [1, 2]           — extra 3 ignored by params\n```\n\nThis flexibility powers default parameters and variadic patterns. **Pitfall:**\nbecause no error is thrown, a typo dropping an argument fails silently with\n`undefined` downstream rather than at the call site.\n",{"id":110,"difficulty":50,"q":111,"a":112},"function-constructor","What is the Function constructor and why avoid it?","The **`Function` constructor** builds a function from **strings** at runtime:\n`new Function('a', 'b', 'return a + b')`. Like `eval`, it executes dynamic\ncode.\n\n```js\nconst add = new Function('a', 'b', 'return a + b')\nadd(2, 3)   \u002F\u002F 5\n\n\u002F\u002F does NOT close over local scope\nfunction outer() {\n  const x = 1\n  return new Function('return x')   \u002F\u002F ReferenceError when called\n}\n```\n\n**Avoid it** because: it bypasses **lexical scope** (only sees global), is a\n**security\u002FCSP risk**, and can't be optimized. Use real functions or closures\ninstead.\n",{"id":114,"difficulty":14,"q":115,"a":116},"generator-function-type","How is a generator function syntactically different from a normal function?","A **generator function** is declared with `function*` and can **pause** at\n`yield`. Calling it doesn't run the body — it returns an **iterator** object.\n\n```js\nfunction* gen() { yield 1; yield 2 }\nconst it = gen()        \u002F\u002F nothing logged yet\nit.next()               \u002F\u002F { value: 1, done: false }\n```\n\nIt's a distinct function *type* from declarations, expressions, and arrows.\n**Pitfall:** there is **no arrow generator** syntax — `*() => {}` is invalid;\ngenerators must use `function*`.\n",{"id":118,"difficulty":14,"q":119,"a":120},"async-function-type","What makes an async function a distinct function type?","An **`async` function** always **returns a Promise** and may use `await`\ninside to pause until a Promise settles. The `async` keyword changes the\nfunction's return contract.\n\n```js\nasync function load() {\n  const r = await fetch('\u002Fapi')   \u002F\u002F pauses without blocking the thread\n  return r.json()                  \u002F\u002F wrapped in a Promise automatically\n}\nload().then(data => \u002F* ... *\u002F data)   \u002F\u002F returns a Promise\n```\n\nArrows can be async too: `const f = async () => {}`. **Pitfall:** even a\n`return 5` inside an async function yields `Promise\u003C5>`, not `5`, so callers\nmust `await` or `.then` it.\n",{"id":122,"difficulty":14,"q":123,"a":124},"constructor-functions","What is a constructor function and how is `new` involved?","A **constructor function** is a regular function intended to be called with\n**`new`**. `new` creates a fresh object, sets its prototype, binds `this` to\nit, runs the body, and returns the object.\n\n```js\nfunction User(name) { this.name = name }   \u002F\u002F convention: capitalized\nconst u = new User('Ada')   \u002F\u002F this -> new object\nUser('Bob')                 \u002F\u002F no `new`: `this` is undefined\u002Fglobal\n```\n\n**Pitfall:** forgetting `new` is a classic bug — `this` leaks to the global\nobject (or throws in strict mode). ES6 **classes** make this safer by throwing\nif you call them without `new`.\n",{"id":126,"difficulty":50,"q":127,"a":128},"hoisting-fn-vs-class","How does hoisting differ between function declarations and function expressions assigned to let\u002Fconst?","**Function declarations** are fully hoisted — name and body — so they're\ncallable from the top of the scope. **`let`\u002F`const` expressions** are hoisted\nonly as **uninitialized bindings** in the temporal dead zone (TDZ).\n\n```js\ndecl()            \u002F\u002F works\nfunction decl() {}\n\nexpr()            \u002F\u002F ReferenceError — TDZ\nconst expr = () => {}\n```\n\nWith `var`, the variable hoists as `undefined`, so calling early gives a\n**TypeError** (`undefined is not a function`) instead. **Pitfall:** relying on\ndeclaration hoisting can obscure code order — many style guides discourage it.\n",{"id":130,"difficulty":14,"q":131,"a":132},"default-with-rest","Can you combine default parameters, destructuring, and rest in one signature?","Yes — JS lets you mix all parameter features, though **rest must come last**\nand a rest parameter **cannot have a default**.\n\n```js\nfunction config({ debug = false } = {}, ...plugins) {\n  return { debug, count: plugins.length }\n}\nconfig({ debug: true }, 'a', 'b')   \u002F\u002F { debug: true, count: 2 }\n\nfunction bad(...args = []) {}   \u002F\u002F SyntaxError — rest can't default\n```\n\n**Pitfall:** ordering matters — a default-valued parameter after a rest\nparameter is a syntax error, and forgetting the `= {}` on the destructured\nobject breaks no-argument calls.\n",{"id":134,"difficulty":14,"q":135,"a":136},"closures-over-params","How do parameters participate in closures?","Parameters are **local variables** of a function, so an inner function closes\nover them just like any other local. This is the basis of **factory functions**\nand partial application.\n\n```js\nfunction multiplier(factor) {        \u002F\u002F `factor` is a parameter...\n  return n => n * factor             \u002F\u002F ...captured by the returned closure\n}\nconst triple = multiplier(3)\ntriple(5)   \u002F\u002F 15   factor remembered\n```\n\nEach call to `multiplier` creates a **new** `factor` binding, so `double` and\n`triple` don't interfere. **Pitfall:** capturing a parameter that's later\nreassigned inside the outer function captures the **latest** value, not a\nsnapshot.\n",{"id":138,"difficulty":50,"q":139,"a":140},"getter-setter-functions","How do getter and setter functions differ from normal methods?","**Getters\u002Fsetters** are functions defined with `get`\u002F`set` that are invoked by\n**property access syntax** rather than a call — `obj.x` runs the getter,\n`obj.x = 1` runs the setter.\n\n```js\nconst temp = {\n  _c: 0,\n  get fahrenheit() { return this._c * 9\u002F5 + 32 },\n  set fahrenheit(f) { this._c = (f - 32) * 5\u002F9 }\n}\ntemp.fahrenheit = 212   \u002F\u002F calls setter\ntemp.fahrenheit         \u002F\u002F 212 — calls getter, no parentheses\n```\n\nThey enable **computed\u002Fvalidated properties** with a plain-property API.\n**Pitfall:** a getter that does heavy work runs on **every access**, and a\ngetter without a matching setter makes the property silently read-only (or\nthrows in strict mode on assignment).\n",{"id":142,"difficulty":50,"q":143,"a":144},"named-fn-expr-scope","Where is the name of a named function expression visible?","The name of a **named function expression** is bound **only inside the\nfunction's own body**, not in the surrounding scope. It exists so the function\ncan refer to itself.\n\n```js\nconst f = function rec(n) {\n  return n \u003C= 0 ? 0 : n + rec(n - 1)   \u002F\u002F `rec` visible here\n}\nf(3)    \u002F\u002F 6\nrec(3)  \u002F\u002F ReferenceError — `rec` not visible outside\n```\n\nThis makes recursion **safe against reassignment** of the outer variable\n(`f`). **Pitfall:** people expect the inner name to be accessible globally and\nare surprised by the ReferenceError outside.\n",null,{"description":11},"JavaScript function types and parameters interview questions — declarations vs expressions vs arrows, IIFEs, default and rest parameters, the arguments object, destructuring, arity, and first-class functions.","javascript\u002Ffunctions\u002Ffunction-types-parameters","Function Types & Parameters","Functions","functions","2026-06-18","MiP0SVPSrtWDSewPOQD8HZryX7lAoHl2TtUKXP5mnFQ",[155,159,162,166,167],{"subtopic":156,"path":157,"order":158},"Closures","\u002Fjavascript\u002Ffunctions\u002Fclosures",1,{"subtopic":160,"path":161,"order":12},"The this Keyword","\u002Fjavascript\u002Ffunctions\u002Fthis-keyword",{"subtopic":163,"path":164,"order":165},"Higher-Order Functions","\u002Fjavascript\u002Ffunctions\u002Fhigher-order-functions",3,{"subtopic":149,"path":21,"order":20},{"subtopic":168,"path":169,"order":170},"Generators & Iterators","\u002Fjavascript\u002Ffunctions\u002Fgenerators-iterators",5,{"path":172,"title":173},"\u002Fblog\u002Fjavascript-function-types-parameters","JavaScript Function Types & Parameters — Declarations, Arrows, Defaults and Rest",1781808676289]