When you want to create and link complex animations, but would like to avoid creating tens or hundreds of keyframes by hand, try using expressions. An expression is a little piece of software—much like a script—that evaluates to a single value for a single layer property at a specific point in time. Whereas scripts tell an application to do something, an expression says that a property is something.

With expressions, you can create relationships between layer properties and use the keyframes of one property to dynamically animate other layers. For example, you can use the pick whip to link path properties, so a mask can take its path from a brush stroke or a shape layer object.

The expression language is based on the standard JavaScript language, but you do not need to know JavaScript to use expressions. You can create expressions by using the pick whip or by copying simple examples and modifying them to suit your needs.

Animation presets can include expressions, or even consist entirely of an expression. Animation presets that use expressions instead of keyframes are sometimes called behaviors.

After you add an expression to a property, you can continue to add or edit keyframes for the property. An expression can take the value of a property as determined by its keyframes and use that as input to generate new, modified values. For example, the following expression on the Rotation property of a layer adds 90 degrees to the value of the Rotation property, in addition to the keyframed motion:

  value + 90

Some methods—such as wiggle—operate directly on the keyframed property values. (See Property attributes and methods (expression reference).)

The following expression on the Position property of a layer preserves the keyframed motion of the layer and causes it to wiggle a little:

  wiggle(10, 10)

When you are animating text, you can use the Expression selector to specify how much you want an animator property to affect each text character. You can add one or more Expression selectors to an animator group, and that animator group can contain one or more properties.

Follow along with this example to learn how to use the After Effects expression language reference to write expressions. The expression created in this example links the Position property of Solid 2 to the Position property of Solid 1, with the movement of Solid 2 offset by 2 seconds from the movement of Solid 1.

1. Create two solid layers: Solid 1 and Solid 2.

2. Animate the Position property values for Solid 1 using keyframes. (See About animation, keyframes, and expressions.)

3. Select the Position property for Solid 2 and choose Animation > Add Expression or Alt-click (Windows) or Option-click the stopwatch button for the property. The following expression appears by default:

     transform.position

4. Type the following directly over transform.position:

     thisComp

5. The element thisComp is a global attribute whose value is a Comp object representing the current composition. To determine what can follow thisComp in your expression, look up the return value for thisComp under Global objects, attributes, and methods (expression reference).

   Note that thisComp returns a Comp object. Next, look at Comp attributes and methods (expression reference) to see which attributes and methods you can use with a Comp object. One option is layer(index). The index, or number, inside the parentheses specifies the layer that you want to use. For this example, we assume that Solid 1 is the first layer in your composition. To retrieve values from the first layer in the active composition, type .layer(1) at the end of the expression, to get the following:

     thisComp.layer(1)

6. Again, look at the expression elements reference to see that layer(index) returns a Layer object. Look at Layer General attributes and methods (expression reference), and find the element you want to use. For example, if you want to get the values of the Position property for the layer, type .position at the end of the expression to get the following:

     thisComp.layer(1).position 

7. From Layer General attributes and methods (expression reference), you can see that the position attribute returns a property. Look up Property attributes and methods (expression reference) and notice that you can add a time factor to the expression. To add a specific time, such as current time plus 2 seconds, type .valueAtTime(time+2)at the end of the expression to get the following:

     thisComp.layer(1).position.valueAtTime(time+2)

8. From Property attributes and methods (expression reference), notice that the valueAtTime method returns a Number or Array. When an expression returns a Number, Array, or Boolean (true or false), you cannot add further attributes or methods to the expression (if you want, however, you can add arithmetic operators, such as +, -, *, and /).

In Graph Editor mode, the single expression field appears as a resizable box at the bottom of the Graph Editor and shows only the expression for the selected property. To show multiple expression fields simultaneously, the Timeline panel must be in layer bar mode.

To toggle between layer bar mode and Graph Editor mode, press Shift+F3.

• To show only properties with expressions, select one or more layers, and then press EE.
• To show the expression field in the Graph Editor, choose Show Expression Editor from the Choose Graph Type And Options menu at the bottom of the Graph Editor. When you add a new expression to a property, the expression editor is shown, regardless of this setting.
  To resize the expression field, drag its bottom edge up or down.
• To see how an expression changes the value or velocity graph, click the Show Post-Expression Graph button while showing the value or velocity graph in the Graph Editor.

  The dimly colored graph displays the value or velocity before the expression is applied, and the brightly colored graph displays the value or velocity after the expression is applied. Turning on the graph overlay for the Position property also changes the motion path display in the Composition panel so that you can see the expression-affected path.

You can use the search field in the Timeline panel to search expressions as well as other components of a property. If the search string appears in an expression, the property and its containing property groups and layer are shown in the filtered set of search results.

The Source Text property of a text layer is interpreted by expressions as a JavaScript String. You can use the pick whip to retrieve the source text from another text layer; however, only the style of the first character of the destination layer is used.

For more information on the JavaScript String object, consult a JavaScript reference resource.

You can use "\r" in a string expression to start a new line of text. For example, to copy the original text from one layer onto the same layer and repeat it in all uppercase characters on a new line, use the following expression:

  text.sourceText + "\r" + text.sourceText.toUpperCase()

Adding a text layer to a composition and adding an expression to its Source Text property can be a great way to examine the property values of other layers. For example, the following expression on a Source Text property reports the name and value of the Opacity property for the next layer in the layer stacking order:

  thisComp.layer(index + 1).name + "\rOpacity = " + thisComp.layer(index + 1).opacity.value

The following example reports the name of the footage item used as the source of the topmost image layer in the stacking order at the current time that has its Video switch set.

  source_footage_name = ""; 
  for (i = 1; i <= thisComp.numLayers; i++){ 
      if (i == index) continue; 
      my_layer = thisComp.layer(i); 
      if (! (my_layer.hasVideo && my_layer.active)) continue; 
      if (time >= my_layer.inPoint && time < my_layer.outPoint){ 
          try{ 
              source_footage_name = my_layer.source.name; 
          }catch(err1){ 
              source_footage_name = my_layer.name 
          } 
          break; 
      } 
  } 
  source_footage_name

Aharon Rabinowitz provides a video tutorial and example expressions on Red Giant TV that show how to animate a video game score with the Source Text property and a Slider effect (an Expression Controls effect).

Harry Frank provides a tutorial on his graymachine website that shows how to use expressions to read data from an external text file.

• Type // at the beginning of the comment. Any text between // and the end of the line is ignored. For example:

    // This is a comment.

  For examples of this type of comment, see Expression example: Fade opacity of a 3D layer based on distance from camera.

• Type /* at the beginning of the comment and */ at the end of the comment. Any text between /* and */ is ignored. For example:

    /*  This is a   
        multiline comment. */

  For examples of this type of comment, see Save and reuse expressions.

  function average(a, b) 
  { 
    return (a + b) / 2; 
  } 
  average(position, thisComp.layer(1).position); 

  /*  This expression on a Source Text property reports the name 
      of a layer and the value of its Opacity property. */  
    
  var myLayerIndex = 1; // layer to inspect, initialized to 1, for top layer  
    
  thisComp.layer(myLayerIndex).name + ": \rOpacity = " +   thisComp.layer(myLayerIndex).opacity.value

• To copy an expression and keyframes from one property to other properties, select the source layer property in the Timeline panel, copy the layer property, select the target layer properties, and paste.
• To copy an expression from one property to other properties without copying keyframes, select the source property, choose Edit > Copy Expression Only, select the target properties, and paste.
  Copying an expression without keyframes is useful when you want to simultaneously copy multiple expressions and paste them onto one or more new layers, or when you want to copy one expression and paste it onto more than one layer.

The After Effects expression language is based on JavaScript 1.2, with an extended set of built-in objects. After Effects uses only the core standard JavaScript 1.2 language, not the web browser–specific extensions. After Effects contains its own set of extension objects—such as Layer, Comp, Footage, and Camera—that you can use to get most of the values in an After Effects project.

Though the expression language is based on a scripting language, a subtle but important difference exists between a script and an expression: Whereas a script tells an application to do something, an expression says that a property is something.

For more information about JavaScript, see a JavaScript reference resource.

When creating expressions, keep in mind the following:

• The value of an expression is the value of the last statement evaluated.

• JavaScript is a case-sensitive language.

• Semicolons are required to separate statements or lines.

• Spaces between words are ignored, except within a string.

In JavaScript, a value stored in an object is called a property. However, After Effects uses the term property to refer to layer components as defined in the Timeline panel. For this reason, After Effects refers to JavaScript properties as either methods or attributes. In general practice, the difference between a method and an attribute is that a method usually does something to create its output (return) value, whereas an attribute simply refers to an existing value to determine its output (return) value. You can tell a method from an attribute most easily by looking for the parentheses following the method name, which surround any input arguments to the method.

An object is an item that can contain other objects, attributes, and methods. Compositions, layers, and footage items are examples of objects. Specifically, compositions, layers, and footage items are global objects, which means that they can be referred to in any context without reference to some higher-level object.

If an expression cannot be processed, After Effects displays a message explaining the error and automatically disables the expression. A yellow warning icon appears next to the expression; click the warning icon to view the error message again.

To show expressions that have errors, select one or more layers, right-click (Windows) or Control-click (Mac OS) a selected layer in the Timeline panel, and choose Reveal Expression Errors from the context menu.

Precomposing multiple layers can also cause expressions that refer to a property of one of the layers to produce an error, requiring you to update these expressions to refer to the layer within the new composition. This is especially a concern with expressions that use thisComp instead of referring to a composition by its name. (See About precomposing and nesting.)

Jeff Almasol provides a script on his redefinery website with which you can replace instances of thisComp with explicit references to a composition’s name.