Iterator dan Alur Kerja Berulang

Imagine you receive an email with a list of 10 new customer orders, but you need to process each order individually. How do you do that with automation?

This is where iterators come in! An iterator is a powerful tool in no-code platforms that helps you handle multiple items from a single piece of data, one by one.

Normally, a trigger like 'New Email' might give you one email. If that email contains a simple list (like a string of comma-separated names), a regular action might only see it as one big text block.

• Without an iterator: Your automation would treat the entire list as a single item.
• Result: You couldn't perform actions specifically for each item within that list.

Iterators are incredibly useful for handling 'list-like' data. Here are some common scenarios:

• Processing multiple line items from an invoice.
• Adding several new contacts from a single form submission.
• Creating tasks for each item in a project list.
• Sending personalized emails to a group of recipients found in one database entry.

Think of an iterator as a data splitter. When it receives a list of items (e.g., an array of objects or a comma-separated string), it takes each item and passes it on individually to the next step in your workflow.

It essentially turns a 'one-to-many' input into a series of 'one-to-one' processes.

In most no-code platforms, an iterator often sits right after a trigger or an action that outputs a list. Here's a conceptual flow:

• Step 1: Trigger (e.g., New Google Sheet Row)
• Step 2: Action (e.g., Find related items, which returns a list)
• Step 3: Iterator (takes the list from Step 2)
• Step 4: Action (processes each item from the iterator)

Iterators are designed to work with structured lists. Common inputs include:

• Arrays of Objects: A list where each item has multiple properties (e.g., [{name: "Alice"}, {name: "Bob"}]).
• Arrays of Strings/Numbers: Simple lists like ["Apple", "Banana", "Cherry"].
• Some platforms can also parse comma-separated values (CSV) or line-separated text into lists.

Once an iterator splits your list, the actions that follow it will run once for every single item the iterator processes. This is the core of looping workflows!

For example, if your iterator processes 5 line items from an order, the 'Create Task' action after it will run 5 times, creating one task for each line item.

The output of an iterator for subsequent steps is simply the current item being processed. This means you can map fields from that individual item to your next action.

• If an iterator processes {name: "Alice", email: "a@b.com"}, the next step can use "Alice" for a name field and "a@b.com" for an email field.
• This happens sequentially for each item until the list is exhausted.

While powerful, iterators can be tricky. Here are common issues to watch out for:

• Not receiving a list: If the input isn't a true list, the iterator might not work or process only one item.
• Too many items: Processing thousands of items can hit platform limits or take a long time.
• Incorrect mapping: Ensure you're mapping the iterated item's data, not the original full list.
• Nested lists: Dealing with lists inside lists often requires multiple iterator steps.

Great job! You've explored iterators, a key component for handling lists in no-code automation.

• Iterators break down lists into individual items.
• They enable "looping workflows," running subsequent actions for each item.
• They are crucial for bulk operations and processing list-based data.
• Always ensure your input is a proper list and manage potential performance impacts.

Mastering iterators unlocks much more powerful and flexible automations!