Now, we'll start to do things that can actually be

(((grammar)))(((JavaScript,syntax)))In the previous chapter, we made

//Ok to move the Luigi example to before you describe undefined variables? Having it

//after made me expect a different sort of example. /JG

As an example, to remember the amount of dollars that Luigi still owes

you, you could create a variable. And then when he pays back 35 dollars, you'd

surrounding system. For example, your browser's environment

contains variables pointing at functions that read your mouse and keyboard input,

which allow you to inspect and influence the currently loaded website.

//Do I have you right with my edits above? I found the last sentence a little

//hard to follow, so I tried to clarify. /JG

function is a piece of a program wrapped in a value. Such values can be

//Do I have you right with my edits below? /JG

parentheses after any expression that produces a function value.

Usually, however, you'll directly refer to a variable that holds a

is hidden by default, but you can find in the menu if you dig.

Just look for an item like “web console” or “developer tools”,

usually under a “Tools” or “Developer” sub-menu.

//Would it make sense to provide an example menu sequence for an existing broswer? /JG

For the examples in this book, any `console.log` output will be

shown below the example, instead of in the browser's JavaScript console.

//I was a bit confused by the paragraph above, so I tried to clarify.

//Do I have you right?

`console.log` clearly has one. That's because `console.log` isn't

a simple variable. It's actually an expression that

//Maybe we should italicize the first instance of side effect below? /JG

are useful because of the side effects they produce. Fuctions an also

need to have side effects to be useful. For example, the

in JavaScript, which means function calls can be used within bigger

straight-line order isn't the only option.

_Conditional execution_ is common, and it lets a program choose between two

In JavaScript, conditional execution is written with the `if` keyword.

This keyword (((if keyword))) tells a program execute or skip a

statement depending on the value of a boolean expression. It is always

followed by an expression between parentheses and then a statement.

//I moved the details of the if keyword to the paragraph above; do I have this right? /JG

With this modification, if you enter anything that isn't a number, like

“cheese” or even nothing at all, no output will be shown.

The `isNaN` function is a standard JavaScript function that returns `true` if the

argument it is given is `NaN`. The `Number` function returns

Thus, the condition translates to, “unless `theNumber` is not-a-number, do

case when the condition doesn't hold. This alternate path is represented by the

//Would it make sense to say flow chart instead of arrow schema below? /JG

The arrow schema for this program looks something like this:

(`{` and `}`). Similar to what parentheses do for expressions, braces

group statements together, making them count as a single statement.

it should stop after that first execution. To reflect this, the test is

//What do you think about boxing this section on indenting code? It just feels

//like a detour from discussing loops, so it might make sense to it apart. /JG

you felt like it, but using ((indentation)) inside blocks

makes the code's structure clear. In complex code, where new blocks open

inside other blocks, it can become hard to see

provide a slightly shorter and more comprehensive form, called the `for` loop:

(((looping,termination)))(((break keyword)))It's possible for a loop to finish

without having its condition produce `false`. A

Let's look at the `break` statement in action. This program finds the first

number that is both greater than or equal to 20 and divisible by 7:

an _((infinite loop))_. A program running an infinite

//Saying that the case structure "continues past" other labels made it

//sound as though it skips the code under those labels, so I tried to clarify.

//Do I have you right? /JG

//Since these aren't the coded solutions, would it make sense to wrap them in !!hint!!? /JG

solved it, feel proud!)

//Did you mean "word or words to output" below or "word or number," instead of "word or word"? /JG

the word or word to output, and print either this word or the number