Briefly introduce After Effects expressions and their importance in animation and motion graphics. Highlight that even beginners can utilize expressions to enhance their projects and workflow.

**1. Wiggle() Expression**:

- Explain what the wiggle() expression does: creates random motion.
- Provide a simple example with position property animation.

```
// Example of using wiggle() to create random motion
wiggle(3, 50);
```

**2. LoopOut() Expression**:

- Describe loopOut() for looping animations.
- Demonstrate both ping-pong and continuous looping.

```
// Example of using loopOut() for continuous looping
loopOut("cycle");
```

**3. ValueAtTime() Expression**:

- Illustrate how to retrieve property values at specific times.

```
// Example of using valueAtTime() to retrieve property values at specific times
valueAtTime(2);
```

**4. Linear() Expression**:

- Explain how linear() maps values from one range to another.
- Provide an example of easing animations with linear().

```
// Example of using linear() for easing animations
linear(time, 0, 5, 0, 100);
```

**5. Ease() Expression**:

- Detail how ease() applies custom easing to animations.
- Show how to create smooth transitions using ease().

```
// Example of using ease() for custom easing
ease(time, 0, 5, 0, 100);
```

**6. ToComp() Expression**:

- Discuss how to convert coordinates from layer space to composition space.

```
// Example of using toComp() to convert coordinates
toComp([100, 100, 0]);
```

*Where to Apply*: Position properties, especially when you need to reference positions in relation to the composition.

**7. Clamp() Expression**:

- Explain how clamp() constrains values within a specified range.

```
// Example of using clamp() to constrain values
clamp(value, 0, 100);
```

*Where to Apply*: Any property requiring limiting values within a specific range.

**8. SeedRandom() Expression**:

- Describe seedRandom() for consistent random values.

```
/// Example of using seedRandom() for consistent random values
seedRandom(5);
```

*Where to Apply*: Random animations or properties where consistent randomness is required.

**9. Math.round() Expression**:

- Explain how Math.round() rounds numbers to the nearest integer.

```
// Example of using Math.round() to round numbers
Math.round(value);
```

*Where to Apply*: Any property where you need to round numeric values.

**10. PosterizeTime() Expression**:

- Detail how to reduce frame rate for a strobe effect.

```
// Example of using posterizeTime() for a strobe effect
posterizeTime(5);
```

*Where to Apply*: Time-related properties for creating strobe effects or reducing frame rate.

**11. Random() Expression**:

- Show how to generate random numbers within a range.

```
// Example of using random() to generate random numbers
random(0, 100);
```

*Where to Apply*: Any property requiring randomized values, such as opacity or position.

**12. Value + Value Expression**:

- Explain how to add two values together.

```
// Example of adding two values together
value + 10;
```

*Where to Apply*: Any property where you want to add a constant value.

**13. Value – Value Expression**:

- Demonstrate subtracting one value from another.

```
// Example of subtracting one value from another
value - 50;
```

*Where to Apply*: Any property where you want to subtract a constant value.

**14. Value * Value Expression**:

- Show how to multiply two values together.

```
// Example of multiplying two values together
value * 2;
```

*Where to Apply*: Any property where you want to multiply by a constant factor.

**15. Value / Value Expression**:

- Explain division operation.

```
// Example of dividing one value by another
value / 2;
```

*Where to Apply*: Any property where you want to divide by a constant factor.

**16. Value % Value Expression**:

- Illustrate modulo operation for returning remainders.

```
// Example of using modulo operation
value % 10;
```

*Where to Apply*: Any property where you want to get the remainder of a division operation.

**17. Math.floor() Expression**:

- Describe how to round down numbers to the nearest integer.

```
// Example of using Math.floor() to round down
Math.floor(value);
```

*Where to Apply*: Any property where you want to round down to the nearest integer.

**18. Math.ceil() Expression**:

- Explain how to round up numbers to the nearest integer.

```
// Example of using Math.ceil() to round up
Math.ceil(value);
```

*Where to Apply*: Any property where you want to round up to the nearest integer.

**19. Math.min() Expression**:

- Detail how to find the smallest of two or more numbers.

```
// Example of using Math.min() to find the smallest value
Math.min(value1, value2);
```

*Where to Apply*: Any property where you want to find the minimum value among several.

**20. Math.max() Expression**:

- Describe finding the largest of two or more numbers.

```
// Example of using Math.max() to find the largest value
Math.max(value1, value2);
```

*Where to Apply*: Any property where you want to find the maximum value among several.

**21. Math.abs() Expression**:

- Explain how to get the absolute value of a number.

```
// Example of using Math.abs() to get the absolute value
Math.abs(value);
```

*Where to Apply*: Any property where you want to ensure a positive value.

**22. Math.sin() Expression**:

- Demonstrate using sine function for oscillating animations.

```
// Example of using Math.sin() for oscillating animations
Math.sin(time);
```

*Where to Apply*: Any property where you want to create smooth oscillating motion.

**23. Math.cos() Expression**:

- Illustrate using cosine function for oscillating animations.

```
// Example of using Math.cos() for oscillating animations
Math.cos(time);
```

*Where to Apply*: Similar to Math.sin(), useful for creating smooth oscillating motion.

**24. Math.PI Constant**:

- Explain the mathematical constant Pi.

```
// Example of using Math.PI constant
Math.PI;
```

*Where to Apply*: Any property where you need to use Pi in mathematical calculations.

**25. Linear() for Color Expression**:

- Detail interpolating between two colors.

```
// Example of using linear() for color interpolation
linear(time, 0, 5, [1, 0, 0], [0, 1, 0]);
```

*Where to Apply*: Color-related properties for smooth color transitions.

**26. Length() Expression**:

- Describe finding the length of an array.

```
// Example of using length() to find the length of an array
length(myArray);
```

*Where to Apply*: Any property where you need to know the length of an array.

**27. Math.sqrt() Expression**:

- Explain finding the square root of a number.

```
// Example of using Math.sqrt() to find the square root
Math.sqrt(value);
```

*Where to Apply*: Any property where you need to find the square root of a value.

**28. SourceRectAtTime() Expression**:

- Detail accessing source footage dimensions.

```
// Example of using sourceRectAtTime() to access source footage dimensions
sourceRectAtTime();
```

*Where to Apply*: When you need to access the dimensions of source footage.

**29. Math.pow() Expression**:

- Illustrate exponentiation.

```
// Example of using Math.pow() for exponentiation
Math.pow(value, 2);
```

*Where to Apply*: Any property where you need to raise a value to a power.

**30. Value + Time Expression**:

- Demonstrate adding time to a property value for animation.

```
// Example of adding time to a property value
value + time;
```

*Where to Apply*: Any property where you want to animate based on the passage of time.

**31.Transform.Position Expression:**

- Explain accessing the position property of a layer’s transform.

```
// Example of accessing the position property of a layer's transform
transform.position;
```

*Where to Apply*: When you need to access or manipulate a layer’s position.

**32. ValueAtTime() with Arrays Expression**:

- Show retrieving property values at specific times with arrays.

```
// Example of using valueAtTime() with arrays to retrieve property values
valueAtTime(2)[0];
```

*Where to Apply*: Any property where you want to access specific values from an array over time.

**33. Parent Expression**:

- Detail referencing the parent layer of the current layer.

```
// Example of referencing the parent layer
thisComp.layer("Parent Layer").transform.position;
```

*Where to Apply*: When you need to reference properties of the parent layer.

**34. Comp() Expression**:

- Explain referencing the current composition.

```
// Example of referencing the current composition
comp("Composition Name").duration;
```

*Where to Apply*: When you need to reference properties of the current composition.

**35. TimeToFrames() Expression**:

- Describe converting time to frames.

```
// Example of converting time to frames
timeToFrames(time);
```

*Where to Apply*: When you need to work with time in frame units.

**36. FramesToTime() Expression**:

- Explain converting frames to time.

```
// Example of converting frames to time
framesToTime(30);
```

*Where to Apply*: When you need to convert frame units to time.

**37. Linear() with Arrays for Custom Easing Expression**:

- Illustrate using arrays for more precise easing control.

```
// Example of using linear() with arrays for custom easing
linear(time, [0, 1], [2, 10]);
```

*Where to Apply*: Any property where you want to apply custom easing.

**38. Index Expression**:

- Explain returning the index number of the layer.

```
// Example of using index to get the layer's index
index;
```

*Where to Apply*: When you need to reference the layer’s index number.

**39. Layer(Index) Expression**:

- Detail referencing another layer by its index number.

```
// Example of referencing another layer by index number
thisComp.layer(2).transform.position;
```

*Where to Apply*: When you need to reference properties of another layer by its index.

**40. Position Expression with Linear Index Animation**:

- Show animating along a mask path based on layer index.

```
// Example of animating along a mask path based on layer index
thisComp.layer("Layer Name").mask("Mask Name").maskPath.pointOnPath(0.5, time);
```

*Where to Apply*: When you want to animate properties based on layer index.

**41. NearestKey() Expression**:

- Explain finding the nearest keyframe index.

```
// Example of finding the nearest keyframe index
nearestKey(time).index;
```

*Where to Apply*: When you need to reference keyframe indices.

**42. VelocityAtTime() Expression**:

- Detail accessing velocity at a specific time.

```
// Example of accessing velocity at a specific time
velocityAtTime(time);
```

*Where to Apply*: When you need to work with velocity values.

**43. Amplitude, Frequency, Decay Expression**:

- Describe creating oscillating animations with amplitude, frequency, and decay.

```
// Example of creating oscillating animations with amplitude, frequency, and decay
amplitude = 50;
frequency = 2;
decay = 3;
amplitude * Math.sin(frequency * 2 * Math.PI * time) / Math.exp(decay * time);
```

*Where to Apply*: When you want to create oscillating animations with control over amplitude, frequency, and decay.

## Here are the top 10 websites where you can learn more details about After Effects expressions:

**Adobe After Effects Help**

The official Adobe After Effects documentation provides comprehensive guides and tutorials on using expressions: Adobe After Effects Help**School of Motion**

School of Motion offers free tutorials and resources for motion designers, including in-depth tutorials on After Effects expressions: School of Motion**AE Enhancers**

AE Enhancers is a community-driven website dedicated to scripting and expressions in After Effects. It features forums, tutorials, and resources contributed by users: AE Enhancers**MotionScript.com**

MotionScript is a website maintained by Dan Ebberts, a renowned expert in After Effects expressions. It offers a wealth of tutorials, tips, and scripts for using expressions: MotionScript.com**Video Copilot**

Video Copilot provides high-quality tutorials and resources for visual effects and motion graphics, including tutorials on After Effects expressions: Video Copilot**Creative Cow**

Creative Cow hosts a vast collection of tutorials, articles, and forums covering various aspects of motion graphics and visual effects, including After Effects expressions: Creative Cow**Mograph Mentor**

Mograph Mentor offers online courses and tutorials for motion graphics artists. It covers topics such as animation principles, workflow techniques, and After Effects expressions: Mograph Mentor**Graymachine**– Graymachine is a blog by Harry Frank, a motion graphics artist and After Effects expert. It features tutorials, tips, and insights into using After Effects, including expressions: Graymachine**Udemy**

Udemy offers a variety of courses on After Effects, including courses specifically focused on expressions and scripting. You can find courses catering to different skill levels and interests: Udemy After Effects Courses**LinkedIn Learning (formerly Lynda.com)**

LinkedIn Learning provides online courses on a wide range of topics, including After Effects expressions. You can find courses created by industry experts that cover expressions in detail: LinkedIn Learning After Effects Courses

These websites offer a wealth of resources, tutorials, and courses to help you master After Effects expressions and take your motion graphics skills to the next level.