Control Structures - Revision history

Philmasterplus: /* catch */ fix notes

2021-03-06T13:11:19Z

catch: fix notes

← Older revision		Revision as of 13:11, 6 March 2021
Line 195:		Line 195:
	};		};

	~~Note~~: Unlike other programming languages (e.g. Java, JavaScript), <code>catch</code> cannot be used to catch an error that occurs in a preceding <code>try</code> statement.		Notes:
	~~Note:~~ <code>catch</code> cannot be used to "escape" an {{f\|abort}} call--KoLmafia will always halt the script.		* Unlike other programming languages (e.g. Java, JavaScript), <code>catch</code> cannot be used to catch an error that occurs in a preceding <code>try</code> statement.
			* <code>catch</code> cannot be used to "escape" an {{f\|abort}} call--KoLmafia will always halt the script.

	The current form was finalized in r20479. See [https://kolmafia.us/threads/construct-to-swallow-errors-in-ash.25486/ discussion thread].		The current form was finalized in r20479. See [https://kolmafia.us/threads/construct-to-swallow-errors-in-ash.25486/ discussion thread].

Philmasterplus: /* Unconditional */ Add catch statement/expression

2021-03-06T13:10:45Z

Unconditional: Add catch statement/expression

@@ Line 146: / Line 146: @@
+}
 </syntaxhighlight>}}
 ===static===
 {{
@@ Line 171: / Line 170: @@
 *If bar.ash is changed, its static variable is reset, but not foo.ash's.
 *If foo.ash is changed, both scripts' variables are reset.
 ==Loops==

Fredg1: /* for */ no floats

2020-08-08T20:36:42Z

for: no floats

← Older revision		Revision as of 20:36, 8 August 2020
Line 222:		Line 222:

	If you don't specify "c", it defaults to incrementing/decrementing by 1. The first iteration is at a and the last is at b (that is to say, it goes from a to b, inclusive).		If you don't specify "c", it defaults to incrementing/decrementing by 1. The first iteration is at a and the last is at b (that is to say, it goes from a to b, inclusive).

			a, b and c are automatically converted to integers. You can't use floats here.

	===foreach===		===foreach===

Fredg1: /* switch */

2020-07-29T23:04:41Z

switch

← Older revision		Revision as of 23:04, 29 July 2020
Line 74:		Line 74:
	</syntaxhighlight>}}		</syntaxhighlight>}}

	~~Note that each~~ "~~case~~" ~~can only test against a single value; that~~ value can be ~~a variable itself~~, ~~but not a test expression~~.		{{
	<br>		CodeSample\|
			description="variable" and every "value" can be expressions as complex as wanted, as long as their end result is always of the same datatype. NO silent conversion is done, so the following '''will generate an error''':\|
			code=
			<syntaxhighlight>
			switch ( 10 + 1 )
			{
			case "1" + "1":
			// Whatever you want; it doesn't matter, as 11 can't be compared with "11"
			break;
			}
			</syntaxhighlight>}}

	{{		{{
	CodeSample\|		CodeSample\|
Line 98:		Line 109:
	{{		{{
	CodeSample\|		CodeSample\|
	description=If switch has no parameter, ~~then each~~ case is evaluated as a boolean expression, like a string of if-then statements.\|		description=The default value of a switch structure's parameter is true. This means that if switch has no parameter, it is the same as submitting '''switch (true) [...]'''. Each case is then evaluated as a boolean expression, like a string of if-then statements.\|
	code=		code=
	<syntaxhighlight>		<syntaxhighlight>

Fredg1: /* switch */

2019-12-20T22:45:50Z

switch

← Older revision		Revision as of 22:45, 20 December 2019
Line 70:		Line 70:
	default:		default:
	// statements executed if		// statements executed if
	// none of the cases were true ~~(or if no break; was encountered)~~		// none of the cases were true
	}		}
	</syntaxhighlight>}}		</syntaxhighlight>}}

	Note that each "case" can only test against a single value; that value can be a variable itself, but not a test expression.		Note that each "case" can only test against a single value; that value can be a variable itself, but not a test expression.
	~~Also, putting~~ a break; in each case isn't ~~required~~. If no break; is placed on the path taken, once the last line of the case is reached, execution simply goes on, ~~testing against~~ the next case/~~reaching the~~ default.		<br>
			{{
			CodeSample\|
			description=Putting a ''break'' in each case isn't mandatory. If no ''break'' is placed on the path taken, once the last line of the case is reached, execution simply goes on, and will execute (will "fall-through") the content of the next case/default.\|
			code=
			<syntaxhighlight>
			switch ( int guess_my_age )
			{
			case 24:
			case 26:
			print("You were SO close!");
			break;
			case 25:
			print("You got it!");
			break;
			default:
			print("Nope");
			}
			</syntaxhighlight>}}


	{{		{{
Line 91:		Line 110:
	default:		default:
	// statements executed if		// statements executed if
	// none of the cases were true ~~(or if no break; was encountered)~~		// none of the cases were true
	}		}
	</syntaxhighlight>}}		</syntaxhighlight>}}

			The default doesn't need to be the last statement (which is useful when using the aforementioned fall-through mechanic). If the default is placed early (e.g. as the first statement), it will NOT have priority over the other cases; if the value submitted to the switch matches one of the cases, execution will jump to it, even if placed after the default. <br>
			Putting a ''break'' at the end of the switch is generally considered good practice, but achieves nothing.

	==Unconditional==		==Unconditional==

Fredg1: /* switch */ outcome if no break; is placed

2019-12-11T04:12:00Z

switch: outcome if no break; is placed

← Older revision		Revision as of 04:12, 11 December 2019
Line 70:		Line 70:
	default:		default:
	// statements executed if		// statements executed if
	// none of the cases were true		// none of the cases were true (or if no break; was encountered)
	}		}
	</syntaxhighlight>}}		</syntaxhighlight>}}

	Note that each "case" can only test against a single value; that value can be a variable itself, but not a test expression.		Note that each "case" can only test against a single value; that value can be a variable itself, but not a test expression.
			Also, putting a break; in each case isn't required. If no break; is placed on the path taken, once the last line of the case is reached, execution simply goes on, testing against the next case/reaching the default.

	{{		{{
Line 90:		Line 91:
	default:		default:
	// statements executed if		// statements executed if
	// none of the cases were true		// none of the cases were true (or if no break; was encountered)
	}		}
	</syntaxhighlight>}}		</syntaxhighlight>}}

Fredg1: /* Continuation & Exiting */

2019-11-23T21:10:55Z

Continuation & Exiting

← Older revision		Revision as of 21:10, 23 November 2019
Line 264:		Line 264:

	===continue===		===continue===
	Continues on to the next iteration of the loop (skipping any statements in this iteration that occur after the continue statement). In a switch statement, continue is allowed ~~iff~~ the switch is inside a loop, and acts as any other continue.		Continues on to the next iteration of the loop (skipping any statements in this iteration that occur after the continue statement). In a switch statement, continue is allowed if the switch is inside a loop, and acts as any other continue.

	===return===		===return===
	Exits the function and returns the value following the return statement, if specified. Note that the value's datatype must match that of the function itself (void functions can only use return by itself).		Exits the function and returns the value following the return statement, if specified. Note that the value's datatype must match that of the function itself (void functions can only use return by itself).
			If in a switch statement, don't place a break after a return!

	===exit===		===exit===

Fluxxdog: /* static */ Add import implications

2015-05-13T15:56:42Z

static: Add import implications

← Older revision		Revision as of 15:56, 13 May 2015
Line 133:		Line 133:
	// curly braces aren't required if only one statement follows the static keyword.		// curly braces aren't required if only one statement follows the static keyword.
	</syntaxhighlight>}}		</syntaxhighlight>}}
			Keep in mind that when using imports, a static call will only apply to the script that imports it.
			*If foo.ash has a static variable, but bar.ash imports foo.ash, KoLmafia will keep separate values for both foo.ash and bar.ash.
			*If bar.ash is changed, its static variable is reset, but not foo.ash's.
			*If foo.ash is changed, both scripts' variables are reset.

	==Loops==		==Loops==

Gnocchi masala: Revisions 10765, 10772 & 10774 implement static scope for code that is only to be executed once on loading.

2014-03-30T07:23:55Z

Revisions 10765, 10772 & 10774 implement static scope for code that is only to be executed once on loading.

@@ Line 111: / Line 111: @@
     // block2
+}
 </syntaxhighlight>}}

Slyz: add try / finally (these should be added as ASH keywords I think)

2011-04-03T21:05:37Z

add try / finally (these should be added as ASH keywords I think)

@@ Line 91: / Line 91: @@
        // statements executed if
        // none of the cases were true
+}
 </syntaxhighlight>}}