JavaScript syntax - Revision history

Asdf2jkl: /* Functions */ Remove extraneous closing tag

2025-05-13T20:03:34Z

Functions: Remove extraneous closing tag

← Previous revision		Revision as of 20:03, 13 May 2025
Line 1,554:		Line 1,554:
	</syntaxhighlight>		</syntaxhighlight>

	An ''anonymous function'' is simply a function without a name and can be written either using function or arrow notation. In these equivalent examples an anonymous function is passed to the '''map''' function and is applied to each of the elements of the array.~~</syntaxhighlight>~~<ref>{{cite web \|last=Yadav \|first=Amitya \|date=4 October 2024 \|title=Named function vs Anonymous Function Impacts \|url=https://aditya003-ay.medium.com/named-function-vs-anonymous-function-impacts-94e2472ed7bb \|website=medium.com \|access-date=19 February 2025}}</ref>		An ''anonymous function'' is simply a function without a name and can be written either using function or arrow notation. In these equivalent examples an anonymous function is passed to the '''map''' function and is applied to each of the elements of the array.<ref>{{cite web \|last=Yadav \|first=Amitya \|date=4 October 2024 \|title=Named function vs Anonymous Function Impacts \|url=https://aditya003-ay.medium.com/named-function-vs-anonymous-function-impacts-94e2472ed7bb \|website=medium.com \|access-date=19 February 2025}}</ref>

	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">

Z. Patterson: MOS:YOU

2025-04-21T19:43:20Z

MOS:YOU

← Previous revision		Revision as of 19:43, 21 April 2025
Line 250:		Line 250:
	0xFFFF_FFFF_FFFF_FFFE;		0xFFFF_FFFF_FFFF_FFFE;

	// But ~~you~~ cannot use them next to a non-digit number part, or at the start or end		// But users cannot use them next to a non-digit number part, or at the start or end
	_12; // Variable is not defined (the underscore makes it a variable identifier)		_12; // Variable is not defined (the underscore makes it a variable identifier)
	12_; // Syntax error (cannot be at the end of numbers)		12_; // Syntax error (cannot be at the end of numbers)
Line 299:		Line 299:
	console.log(nan !== nan); // true		console.log(nan !== nan); // true

	// ~~You~~ can use the isNaN methods to check for NaN		// Users can use the isNaN methods to check for NaN
	console.log(isNaN("converted to NaN")); // true		console.log(isNaN("converted to NaN")); // true
	console.log(isNaN(NaN)); // true		console.log(isNaN(NaN)); // true
Line 552:		Line 552:
	// Array literals		// Array literals
	myArray = [1, 2]; // length of 2		myArray = [1, 2]; // length of 2
	myArray = [1, 2,]; // same array - ~~You~~ can also have an extra comma at the end		myArray = [1, 2,]; // same array - Users can also have an extra comma at the end

	// It is also possible to not fill in parts of the array		// It is also possible to not fill in parts of the array
Line 843:		Line 843:
	</syntaxhighlight>		</syntaxhighlight>

	Hoisting allows ~~you~~ to use the function before it is "declared":		Hoisting allows users to use the function before it is "declared":

	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">
Line 951:		Line 951:
	</syntaxhighlight>		</syntaxhighlight>

	To always return a non-negative number, re-add the modulus and apply the modulo operator again:		To always return a non-negative number, users can re-add the modulus and apply the modulo operator again:

	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">
Line 957:		Line 957:
	console.log((-x%5+5)%5); // displays 3		console.log((-x%5+5)%5); // displays 3
	</syntaxhighlight>		</syntaxhighlight>
	~~You~~ could also do:		Users could also do:
	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">
	const x = 17;		const x = 17;
Line 1,077:		Line 1,077:
	}		}

	// ~~You~~ can use it even if it passes more parameters than the function will use		// Users can use it even if it passes more parameters than the function will use
	foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);		foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

	// ~~You~~ can mix it with non-spread parameters		// Users can mix it with non-spread parameters
	foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);		foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

Line 1,491:		Line 1,491:
	{{Main\|Function (computer programming)}}		{{Main\|Function (computer programming)}}

	A [[Function (computer programming)\|function]] is a block with a (possibly empty) parameter list that is normally given a name. A function may use local variables. If ~~you~~ ~~exit~~ the function without a return statement, the value {{mono\|undefined}} is returned.		A [[Function (computer programming)\|function]] is a block with a (possibly empty) parameter list that is normally given a name. A function may use local variables. If a user exits the function without a return statement, the value {{mono\|undefined}} is returned.

	<syntaxhighlight lang="javascript+genshitext">		<syntaxhighlight lang="javascript+genshitext">

Z. Patterson: Rescuing 10 sources and tagging 0 as dead.) #IABot (v2.0.9.5

2025-04-20T23:28:41Z

Rescuing 10 sources and tagging 0 as dead.) #IABot (v2.0.9.5

← Previous revision		Revision as of 23:28, 20 April 2025
Line 13:		Line 13:

	==Origins==		==Origins==
	[[Brendan Eich]] summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification<ref>[http://hepunx.rl.ac.uk/~adye/jsspec11/intro.htm#1006028 JavaScript 1.1 specification]</ref><ref>{{cite web\|title=Chapter 1. Basic JavaScript\|url=http://speakingjs.com/es5/ch01.html\|access-date=22 September 2020\|website=speakingjs.com\|archive-date=10 February 2022\|archive-url=https://web.archive.org/web/20220210041253/http://speakingjs.com/es5/ch01.html\|url-status=dead}}</ref> as follows:		[[Brendan Eich]] summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification<ref>{{Cite web \|url=http://hepunx.rl.ac.uk/~adye/jsspec11/intro.htm#1006028 \|title=JavaScript 1.1 specification \|access-date=19 April 2006 \|archive-date=26 February 2017 \|archive-url=https://web.archive.org/web/20170226200426/http://hepunx.rl.ac.uk/~adye/jsspec11/intro.htm#1006028 \|url-status=live }}</ref><ref>{{cite web\|title=Chapter 1. Basic JavaScript\|url=http://speakingjs.com/es5/ch01.html\|access-date=22 September 2020\|website=speakingjs.com\|archive-date=10 February 2022\|archive-url=https://web.archive.org/web/20220210041253/http://speakingjs.com/es5/ch01.html\|url-status=dead}}</ref> as follows:
	{{Quote\|JavaScript borrows most of its syntax from [[Java (programming language)\|Java]], but also inherits from [[Awk]] and [[Perl]], with some indirect influence from [[Self (programming language)\|Self]] in its object prototype system.}}		{{Quote\|JavaScript borrows most of its syntax from [[Java (programming language)\|Java]], but also inherits from [[Awk]] and [[Perl]], with some indirect influence from [[Self (programming language)\|Self]] in its object prototype system.}}

Line 103:		Line 103:
	===Scoping and hoisting===		===Scoping and hoisting===

	Variables declared with <code>var</code> are [[lexical scoping\|lexically scoped]] at a [[function scope\|function level]], while ones with <code>let</code> or <code>const</code> have a [[block scope\|block level]] scope. Since declarations are processed before any code is executed, a variable can be assigned to and used prior to being declared in the code.<ref>{{cite web \|title=JavaScript Hoisting \|publisher=[[W3Schools]] \|url=https://www.w3schools.com/js/js_hoisting.asp \|quote=In JavaScript, a variable can be declared after it has been used. In other words; a variable can be used before it has been declared.}}</ref> This is referred to as ''{{visible anchor\|hoisting}}'', and it is equivalent to variables being [[Forward declaration\|forward declared]] at the top of the function or block.<ref>"[http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html JavaScript Scoping and Hoisting]", [http://www.adequatelygood.com/about.html Ben Cherry], ''[http://www.adequatelygood.com/ Adequately Good],'' 8 February 2010</ref><!-- Might not explain scoping very well -->		Variables declared with <code>var</code> are [[lexical scoping\|lexically scoped]] at a [[function scope\|function level]], while ones with <code>let</code> or <code>const</code> have a [[block scope\|block level]] scope. Since declarations are processed before any code is executed, a variable can be assigned to and used prior to being declared in the code.<ref>{{cite web \|title=JavaScript Hoisting \|publisher=[[W3Schools]] \|url=https://www.w3schools.com/js/js_hoisting.asp \|quote=In JavaScript, a variable can be declared after it has been used. In other words; a variable can be used before it has been declared. \|access-date=17 December 2021 \|archive-date=31 March 2022 \|archive-url=https://web.archive.org/web/20220331225545/https://www.w3schools.com/js/js_hoisting.asp \|url-status=live }}</ref> This is referred to as ''{{visible anchor\|hoisting}}'', and it is equivalent to variables being [[Forward declaration\|forward declared]] at the top of the function or block.<ref>"[http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html JavaScript Scoping and Hoisting] {{Webarchive\|url=https://web.archive.org/web/20210508121632/http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html \|date=8 May 2021 }}", [http://www.adequatelygood.com/about.html Ben Cherry] {{Webarchive\|url=https://web.archive.org/web/20210228091155/http://www.adequatelygood.com/about.html \|date=28 February 2021 }}, ''[http://www.adequatelygood.com/ Adequately Good] {{Webarchive\|url=https://web.archive.org/web/20220308081510/http://www.adequatelygood.com/ \|date=8 March 2022 }},'' 8 February 2010</ref><!-- Might not explain scoping very well -->

	With <code>var</code>, <code>let</code>, and <code>const</code> statements, only the declaration is hoisted; assignments are not hoisted. Thus a {{code\|lang=javascript\|code=var x = 1}} statement in the middle of the function is equivalent to a {{code\|lang=javascript\|code=var x}} declaration statement at the top of the function, and an {{code\|lang=javascript\|code=x = 1}} assignment statement at that point in the middle of the function. This means that values cannot be accessed before they are declared; [[forward reference]] is not possible. With <code>var</code> a variable's value is <code>undefined</code> until it is initialized. Variables declared with <code>let</code> or <code>const</code> cannot be accessed until they have been initialized, so referencing such variables before will cause an error.<!-- Some sources: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var#var_hoisting. Referencing a let or const will not throw if there's a type of. An exception to the typeof exception is "const x = x;", which you can try in the console. -->		With <code>var</code>, <code>let</code>, and <code>const</code> statements, only the declaration is hoisted; assignments are not hoisted. Thus a {{code\|lang=javascript\|code=var x = 1}} statement in the middle of the function is equivalent to a {{code\|lang=javascript\|code=var x}} declaration statement at the top of the function, and an {{code\|lang=javascript\|code=x = 1}} assignment statement at that point in the middle of the function. This means that values cannot be accessed before they are declared; [[forward reference]] is not possible. With <code>var</code> a variable's value is <code>undefined</code> until it is initialized. Variables declared with <code>let</code> or <code>const</code> cannot be accessed until they have been initialized, so referencing such variables before will cause an error.<!-- Some sources: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var#var_hoisting. Referencing a let or const will not throw if there's a type of. An exception to the typeof exception is "const x = x;", which you can try in the console. -->
Line 312:		Line 312:

	=== String ===		=== String ===
	A [[String (computer science)\|string]] in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (") or single (') quotes. Such strings must be written on a single line, but may include escaped newline characters (such as \n). The JavaScript standard allows the [[Grave accent#Use in programming\|backquote]] character (`, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as embedded expressions using the syntax ${''expression''}.<ref>{{cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\|title=Template literals\|website=MDN Web Docs\|language=en-US\|access-date=4 November 2023}}</ref>		A [[String (computer science)\|string]] in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (") or single (') quotes. Such strings must be written on a single line, but may include escaped newline characters (such as \n). The JavaScript standard allows the [[Grave accent#Use in programming\|backquote]] character (`, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as embedded expressions using the syntax ${''expression''}.<ref>{{cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\|title=Template literals\|website=MDN Web Docs\|language=en-US\|access-date=4 November 2023\|archive-date=31 March 2022\|archive-url=https://web.archive.org/web/20220331204510/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\|url-status=live}}</ref>

	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">
Line 394:		Line 394:
	Automatic type coercion by the equality comparison operators (<code>==</code> and <code>!=</code>) can be avoided by using the type checked comparison operators (<code>===</code> and <code>!==</code>).		Automatic type coercion by the equality comparison operators (<code>==</code> and <code>!=</code>) can be avoided by using the type checked comparison operators (<code>===</code> and <code>!==</code>).

	When type conversion is required, JavaScript converts {{mono\|Boolean}}, {{mono\|Number}}, {{mono\|String}}, or {{mono\|Object}} operands as follows:<ref>{{cite web \| url=https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators \| title=Comparison Operators - MDC Doc Center \| publisher=Mozilla \| date=5 August 2010 \| access-date=5 March 2011}}</ref>		When type conversion is required, JavaScript converts {{mono\|Boolean}}, {{mono\|Number}}, {{mono\|String}}, or {{mono\|Object}} operands as follows:<ref>{{cite web \| url=https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators \| title=Comparison Operators - MDC Doc Center \| publisher=Mozilla \| date=5 August 2010 \| access-date=5 March 2011 \| archive-date=4 May 2012 \| archive-url=https://web.archive.org/web/20120504005400/https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators \| url-status=live }}</ref>
	;{{small\|Number and String}}: The string is converted to a number value. JavaScript attempts to convert the string numeric literal to a Number type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest Number type value.		;{{small\|Number and String}}: The string is converted to a number value. JavaScript attempts to convert the string numeric literal to a Number type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest Number type value.
	;{{small\|Boolean}}: If one of the operands is a Boolean, the Boolean operand is converted to 1 if it is {{mono\|true}}, or to 0 if it is {{mono\|false}}.		;{{small\|Boolean}}: If one of the operands is a Boolean, the Boolean operand is converted to 1 if it is {{mono\|true}}, or to 0 if it is {{mono\|false}}.
Line 402:		Line 402:
	{{anchor\|truthy and falsy}}		{{anchor\|truthy and falsy}}
	{{further\|Truthy (computing)}}		{{further\|Truthy (computing)}}
	[[Douglas Crockford]] advocates the terms "truthy" and "falsy" to describe how values of various types behave when evaluated in a logical context, especially in regard to edge cases.<ref>{{cite web \| url=http://javascript.crockford.com/style2.html \| title=The Elements of JavaScript Style \| publisher=Douglas Crockford \| access-date=5 March 2011}}</ref>		[[Douglas Crockford]] advocates the terms "truthy" and "falsy" to describe how values of various types behave when evaluated in a logical context, especially in regard to edge cases.<ref>{{cite web \| url=http://javascript.crockford.com/style2.html \| title=The Elements of JavaScript Style \| publisher=Douglas Crockford \| access-date=5 March 2011 \| archive-date=17 March 2011 \| archive-url=https://web.archive.org/web/20110317074944/http://javascript.crockford.com/style2.html \| url-status=live }}</ref>
	The binary logical operators returned a Boolean value in early versions of JavaScript, but now they return one of the operands instead. The left–operand is returned, if it can be evaluated as : {{mono\|false}}, in the case of [[logical conjunction\|conjunction]]: (<code>a && b</code>), or {{mono\|true}}, in the case of [[logical disjunction\|disjunction]]: (<code>a \|\| b</code>); otherwise the right–operand is returned. Automatic type coercion by the comparison operators may differ for cases of mixed Boolean and number-compatible operands (including strings that can be evaluated as a number, or objects that can be evaluated as such a string), because the Boolean operand will be compared as a numeric value. This may be unexpected. An expression can be explicitly cast to a Boolean primitive by doubling the logical [[negation\|negation operator]]: ({{mono\|!!}}), using the {{mono\|Boolean()}} function, or using the [[Conditional (programming)\|conditional operator]]: (<code>c ? t : f</code>).		The binary logical operators returned a Boolean value in early versions of JavaScript, but now they return one of the operands instead. The left–operand is returned, if it can be evaluated as : {{mono\|false}}, in the case of [[logical conjunction\|conjunction]]: (<code>a && b</code>), or {{mono\|true}}, in the case of [[logical disjunction\|disjunction]]: (<code>a \|\| b</code>); otherwise the right–operand is returned. Automatic type coercion by the comparison operators may differ for cases of mixed Boolean and number-compatible operands (including strings that can be evaluated as a number, or objects that can be evaluated as such a string), because the Boolean operand will be compared as a numeric value. This may be unexpected. An expression can be explicitly cast to a Boolean primitive by doubling the logical [[negation\|negation operator]]: ({{mono\|!!}}), using the {{mono\|Boolean()}} function, or using the [[Conditional (programming)\|conditional operator]]: (<code>c ? t : f</code>).

Line 1,053:		Line 1,053:
	==== Spread/rest operator ====		==== Spread/rest operator ====

	The ECMAScript 2015 standard introduced the "<code>...</code>" array operator, for the related concepts of "spread syntax"<ref>{{Cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax\|title=Spread syntax (...) - JavaScript \| MDN\|date=25 September 2023\|website=developer.mozilla.org}}</ref> and "rest parameters".<ref>{{cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters\| title = rest parameters\| date = 9 September 2024}}</ref> Object spreading was added in ECMAScript 2018.		The ECMAScript 2015 standard introduced the "<code>...</code>" array operator, for the related concepts of "spread syntax"<ref>{{Cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax\|title=Spread syntax (...) - JavaScript \| MDN\|date=25 September 2023\|website=developer.mozilla.org}}</ref> and "rest parameters".<ref>{{cite web\| url = https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters\| title = rest parameters\| date = 9 September 2024\| access-date = 29 September 2016\| archive-date = 30 May 2018\| archive-url = https://web.archive.org/web/20180530204951/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters\| url-status = live}}</ref> Object spreading was added in ECMAScript 2018.

	'''Spread syntax''' provides another way to destructure arrays and objects. For arrays, it indicates that the elements should be used as the parameters in a function call or the items in an array literal. For objects, it can be used for merging objects together or overriding properties.		'''Spread syntax''' provides another way to destructure arrays and objects. For arrays, it indicates that the elements should be used as the parameters in a function call or the items in an array literal. For objects, it can be used for merging objects together or overriding properties.
Line 1,825:		Line 1,825:

	===eval (expression) ===		===eval (expression) ===
	Evaluates the first parameter as an expression, which can include assignment statements. Variables local to functions can be referenced by the expression. However, {{code\|eval}} represents a major security risk, as it allows a bad actor to execute arbitrary code, so its use is discouraged.<ref name="deve_eval">{{cite web \|title=eval() \|work=MDN Web Docs \|access-date=29 January 2020 \|url= https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Never_use_eval!}}</ref>		Evaluates the first parameter as an expression, which can include assignment statements. Variables local to functions can be referenced by the expression. However, {{code\|eval}} represents a major security risk, as it allows a bad actor to execute arbitrary code, so its use is discouraged.<ref name="deve_eval">{{cite web \|title=eval() \|work=MDN Web Docs \|access-date=29 January 2020 \|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Never_use_eval! \|archive-date=1 April 2022 \|archive-url=https://web.archive.org/web/20220401220204/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Never_use_eval! \|url-status=live }}</ref>
	<syntaxhighlight lang="nodejsrepl">		<syntaxhighlight lang="nodejsrepl">
	> (function foo() {		> (function foo() {

Z. Patterson: American English, script-assisted date audit and style fixes per MOS:NUM, expanded contractions using script

2025-04-20T23:27:13Z

American English, script-assisted date audit and style fixes per MOS:NUM, expanded contractions using script

Show changes

Cedar101: /* For ... in loop */ nowrap

2025-03-12T01:49:06Z

For ... in loop: nowrap

← Previous revision		Revision as of 01:49, 12 March 2025
Line 1,423:		Line 1,423:
	* Iterates through all enumerable properties of an object.		* Iterates through all enumerable properties of an object.
	* Iterates through all used indices of array including all user-defined properties of array object, if any. Thus it may be better to use a traditional for loop with a numeric index when iterating over arrays.		* Iterates through all used indices of array including all user-defined properties of array object, if any. Thus it may be better to use a traditional for loop with a numeric index when iterating over arrays.
	* There are differences between the various Web browsers with regard to which properties will be reflected with the for...in loop statement. In theory, this is controlled by an internal state property defined by the ECMAscript standard called "DontEnum", but in practice, each browser returns a slightly different set of properties during introspection. It is useful to test for a given property using {{code\|lang=javascript\|code=if (some_object.hasOwnProperty(property_name)) { ... }}}. Thus, adding a method to the array prototype with {{code\|lang=javascript\|code=Array.prototype.newMethod = function() {...}}} may cause <code>for ... in</code> loops to loop over the method's name.		* There are differences between the various Web browsers with regard to which properties will be reflected with the for...in loop statement. In theory, this is controlled by an internal state property defined by the ECMAscript standard called "DontEnum", but in practice, each browser returns a slightly different set of properties during introspection. It is useful to test for a given property using {{nowrap\|{{code\|lang=javascript\|code=if (some_object.hasOwnProperty(property_name)) { ... } }}}}. Thus, adding a method to the array prototype with {{nowrap\|{{code\|lang=javascript\|code=Array.prototype.newMethod = function() {...} }}}} may cause <code>for ... in</code> loops to loop over the method's name.

	===While loop===		===While loop===

AdaHephais: Add internal link

2025-03-11T14:49:55Z

Add internal link

← Previous revision		Revision as of 14:49, 11 March 2025
Line 29:		Line 29:

	===Whitespace and semicolons===		===Whitespace and semicolons===
	Unlike in [[C (programming language)\|C]], whitespace in JavaScript source can directly impact [[Semantics (computer science)\|semantics]]. [[Semicolon]]s end statements in JavaScript. Because of [[Lexical analysis#Semicolon insertion\|automatic semicolon insertion]] (ASI), some statements that are well formed when a newline is parsed will be considered complete, as if a semicolon were inserted just prior to the newline. Some authorities advise supplying statement-terminating semicolons explicitly, because it may lessen unintended effects of the automatic semicolon insertion.<ref>{{cite book		Unlike in [[C (programming language)\|C]], whitespace in JavaScript source can directly impact [[Semantics (computer science)\|semantics]]. [[Semicolon]]s end statements in JavaScript. Because of [[Lexical analysis#Semicolon insertion\|automatic semicolon insertion]] (ASI), some statements that are well formed when a newline is [[Parsing\|parsed]] will be considered complete, as if a semicolon were inserted just prior to the newline. Some authorities advise supplying statement-terminating semicolons explicitly, because it may lessen unintended effects of the automatic semicolon insertion.<ref>{{cite book
	\|title=JavaScript: The definitive Guide		\|title=JavaScript: The definitive Guide
	\|url=https://archive.org/details/javascript00libg_297		\|url=https://archive.org/details/javascript00libg_297

GelvinM: /* Functions - added syntax for generator functions */

2025-02-24T18:06:17Z

Functions - added syntax for generator functions

@@ Line 1,553: / Line 1,553: @@
 </syntaxhighlight>
-An ''anonymous function'' is simply a function without a name and can be written either using function or arrow notation.  In these equivalent examples an anonymous function is passed to the'''map''' function and is applied to each of the elements of the array.
+An ''anonymous function'' is simply a function without a name and can be written either using function or arrow notation.  In these equivalent examples an anonymous function is passed to the  '''map''' function and is applied to each of the elements of the array.</syntaxhighlight><ref>{{cite web |last=Yadav |first=Amitya |date=Oct 4, 2024 |title=Named function vs Anonymous Function Impacts |url=https://aditya003-ay.medium.com/named-function-vs-anonymous-function-impacts-94e2472ed7bb |website=medium.com |access-date=Feb 19, 2025}}</ref>
 <syntaxhighlight lang="javascript">
  [1,2,3].map(function(x) { return x*2;);  //returns [2,4,6]
  [1,2,3].map((x) => { return x*2;});      //same result

GelvinM: Added anonymous functions as arguments

2025-02-19T21:29:39Z

Added anonymous functions as arguments

← Previous revision		Revision as of 21:29, 19 February 2025
Line 322:		Line 322:
	const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;		const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;
	console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''		console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''
	console.log(`You are ${Math.floor(age)>18 ? "allowed" : "not allowed"} to view this web page`);		console.log(`You are ${Math.floor(age)=>18 ? "allowed" : "not allowed"} to view this web page`);
	</syntaxhighlight>		</syntaxhighlight>

Line 1,552:		Line 1,552:
	console.log(t); // Top		console.log(t); // Top
	</syntaxhighlight>		</syntaxhighlight>

			An ''anonymous function'' is simply a function without a name and can be written either using function or arrow notation. In these equivalent examples an anonymous function is passed to the'''map''' function and is applied to each of the elements of the array.

			<syntaxhighlight lang="javascript">
			[1,2,3].map(function(x) { return x*2;); //returns [2,4,6]
			[1,2,3].map((x) => { return x*2;}); //same result
			</syntaxhighlight><ref>{{cite web \|last=Yadav \|first=Amitya \|date=Oct 4, 2024 \|title=Named function vs Anonymous Function Impacts \|url=https://aditya003-ay.medium.com/named-function-vs-anonymous-function-impacts-94e2472ed7bb \|website=medium.com \|access-date=Feb 19, 2025}}</ref>


	===Async/await===		===Async/await===

GelvinM: /* String - embedded expressions inside template strings named and clarified as more than just a simple variable reference */

2025-02-18T05:23:56Z

String - embedded expressions inside template strings named and clarified as more than just a simple variable reference

← Previous revision		Revision as of 05:23, 18 February 2025
Line 311:		Line 311:

	=== String ===		=== String ===
	A [[String (computer science)\|string]] in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (") or single (') quotes. Such strings must be written on a single line, but may include escaped newline characters (such as \n). The JavaScript standard allows the [[Grave accent#Use in programming\|backquote]] character (`, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as ~~template~~ ~~literals,~~ ~~which allow for interpolation of type-coerced evaluated expressions~~ ~~within~~ a ~~string~~.<ref>{{cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\|title=Template literals\|website=MDN Web Docs\|language=en-US\|access-date=2023-11-04}}</ref>		A [[String (computer science)\|string]] in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (") or single (') quotes. Such strings must be written on a single line, but may include escaped newline characters (such as \n). The JavaScript standard allows the [[Grave accent#Use in programming\|backquote]] character (`, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as embedded expressions using the syntax ${''expression''}.<ref>{{cite web\|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\|title=Template literals\|website=MDN Web Docs\|language=en-US\|access-date=2023-11-04}}</ref>

	<syntaxhighlight lang="javascript">		<syntaxhighlight lang="javascript">
Line 322:		Line 322:
	const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;		const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;
	console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''		console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''
			console.log(`You are ${Math.floor(age)>18 ? "allowed" : "not allowed"} to view this web page`);
	</syntaxhighlight>		</syntaxhighlight>

Kvng: add link

2025-01-25T14:47:38Z

add link

← Previous revision		Revision as of 14:47, 25 January 2025
Line 3:		Line 3:
	{{Use dmy dates\|date=April 2022}}		{{Use dmy dates\|date=April 2022}}

	[[File:Source code in Javascript.png\|thumb\|A snippet of [[JavaScript]] code with keywords highlighted in different colors]]		[[File:Source code in Javascript.png\|thumb\|A snippet of [[JavaScript]] code with keywords [[Syntax highlighting\|highlighted]] in different colors]]

	The '''[[Syntax (programming languages)\|syntax]] of [[JavaScript]]''' is the set of rules that define a correctly structured JavaScript program.		The '''[[Syntax (programming languages)\|syntax]] of [[JavaScript]]''' is the set of rules that define a correctly structured JavaScript program.

← Previous revision		Revision as of 14:47, 25 January 2025
Line 3:		Line 3:
	{{Use dmy dates\|date=April 2022}}		{{Use dmy dates\|date=April 2022}}

	[[File:Source code in Javascript.png\|thumb\|A snippet of [[JavaScript]] code with keywords highlighted in different colors]]		[[File:Source code in Javascript.png\|thumb\|A snippet of [[JavaScript]] code with keywords [[Syntax highlighting\|highlighted]] in different colors]]

	The '''[[Syntax (programming languages)\|syntax]] of [[JavaScript]]''' is the set of rules that define a correctly structured JavaScript program.		The '''[[Syntax (programming languages)\|syntax]] of [[JavaScript]]''' is the set of rules that define a correctly structured JavaScript program.