Snap! Cheat Sheet

In Snap!, you must first create a variable before you use assign it a value. You can use the button in the Variables palette to create a global variable or to create a local (script) variable.

There are several ways to display data to the user in Snap!. One way is in the form of speech balloons that are "spoken" by the sprites on the stage. Here is the behavior that results from running the instruction say (expression):

In Snap!, there are also variations on this block such as:

• say for ( ) secs, which will only display the message for a specified number of seconds, and

• think ( ) and think ( ) for ( ) secs, which both display the message as a thought balloon rather than as a speech balloon, like this:
  

The write block is very different, but it’s still a form of output to the user. It writes the contents of the first input slot on the stage in the font size written in the second input slot.

In Snap!, user input is always prompted by running an ask command. The user is asked the question typed into the ask input slot, and their response can be accessed by using the answer block, which can be placed in an input slot just like a variable.

These blocks are straightforward. You can put any numeric expressions in the input slots, including numbers or variables. For example: or

Same as above: You can use any numeric expressions as input. For example:

Same as above: You can use any numeric expressions as input.

The hexagonal block shape indicates that this is a predicate block; it only reports (returns) true or false.

There are no ≠ (not equal), ≥ (greater than or equal), or ≤ (less than or equal) blocks built into Snap!, but they are simple to build as needed: , , and .

Hexagonal input slots indicate that a predicate (true/false) expression (a condition)is expected as input.

Same as above: Hexagonal input slots require predicate inputs.

Same as above: Hexagonal input slots require predicate inputs.

IF (condition)
{
<block of statements>
}

Here is an example of how the if statement could look in Snap! when it has a condition and a sequence of statements:

IF (condition)
{
<first block of statements>
}
ELSE
{
<second block of statements>
}

Here is an example of how the if else statement could look in Snap! when it has a condition and two sequences of statements:

REPEAT n TIMES
{
<block of statements>
}

Here is an example of how the repeat statement could look in Snap! when it has an input number and a sequence of statements:

REPEAT UNTIL (condition)
{
<block of statements>
}

Here is an example of how the repeat until statement could look in Snap! when it has an input number and a sequence of statements:

You can tell what kind of input is expected in each input slot of a block in Snap! by its shape. For example, takes a number as its first input (indicated by the round input slot) and a list as its second input (indicated by the small picture of a list):

In addition, there is a drop-down menu for the first input slot allowing you to select the first, the last, or a random item from the list instead of typing a number or dragging and dropping a variable in.

At first glance, this looks a little different on the exam than in Snap!, but if you read the Snap! out loud, it is clear what it does: It replaces the item at position number i in the list with the item at position number j in the list.

Here’s an example:

In Snap!, it’s recommended not to name any variable list because there is a block called list that creates new lists. Here are some examples of better list names (really, anything but "list" is fine; that variable name is only shown at left to match the AP Exam reference sheet):

FOR EACH item IN list
{
<block of statements>
}

You can change the name of the first variable by clicking it.

Here is an example of how the for each statement could look in Snap! when it has a real list name and a statement inside:

Note that Snap! has two length blocks:

• a "List" length block for measuring lists: and

• an "Operators" length block for measuring strings:

PROCEDURE name (parameter1, parameter2, ...)
{
<instructions>
}

In Snap!, procedures that do something are called commands. Command blocks have a rectangular, puzzle-piece shape because they are instructions to the computer designed to be snapped together one after another.

When you make a block, you choose the name of the block, the input parameters, and the palette it should appear in (the color). Then you design the instructions that will run when the block is clicked. Here is an example of what a real command block definition might look like in Snap!:

You can learn more about making block and adding inputs on the Snap. ! Cheat Sheet

PROCEDURE name (parameter1, parameter2, ...)
{
<instructions>
RETURN expression
}

In Snap!, procedures that report (return) a value are called reporters. Reporter blocks have a rounded shape and they can either be clicked to report a value to the programmer or they can be dropped into an empty input slot of another block to be used as input.

When you make a reporter block, the block definition automatically includes a report block. The value of the expression in the input slot of this report block is the value that is returned when the reporter is run.

Here is an example of what a real reporter block definition might look like in Snap!:

In Snap!, you can use the block to move the sprite forward any number of steps.

In Snap!, you can use the and blocks to turn the sprite any number of degrees.

In Snap!, you can use these blocks to help your sprites determine how to move: , , and