What You Will Learn

• Understand all 106 n8n JavaScript functions organized by category
• Master string, number, array, object, and boolean functions
• Use Luxon datetime functions for formatting and date arithmetic
• Validate and convert data types (toNumber, toBoolean, toString, parseJson)

Study Guide

Introduction

Welcome to the comprehensive guide on n8n JavaScript functions. This course is designed to provide a detailed understanding of each JavaScript function available in n8n, a powerful workflow automation tool. By mastering these functions, you can significantly enhance your workflow efficiency and speed, making you a more effective builder. This guide breaks down the 106 functions into logical categories: string, number, array, object, and boolean functions. Each section will delve into the details, practical applications, and best practices to equip you with the knowledge needed to leverage these tools effectively.

Overview of n8n JavaScript Functions

As of the course recording, n8n offers 106 JavaScript functions categorized into five main groups: string, number, array, object, and boolean functions. Understanding these categories helps organize your knowledge and allows you to locate relevant functions based on the data type you are manipulating. The course aims to cover each function comprehensively, equipping you with the skills to enhance your workflow automation.

String Functions

String functions are essential for manipulating text data. Here are some of the most important string functions you'll encounter in n8n:

includes(): Checks if a string contains a specified substring.
Example: 'hello'.includes('hell') returns true.

split(): Converts a string into an array of substrings based on a delimiter.
Example: 'Sarah, Sally, Stephanie'.split(', ') returns ['Sarah', 'Sally', 'Stephanie'].

startsWith() and endsWith(): Check if a string begins or ends with a specified substring.
Example: 'hello'.startsWith('he') returns true.

replaceAll(): Replaces all occurrences of a substring within a string with another substring.
Example: 'foo bar foo'.replaceAll('foo', 'baz') returns 'baz bar baz'.

These functions are incredibly useful in various scenarios, such as parsing CSV data, checking for specific prefixes or suffixes, and sanitizing input data.

Number Functions

Number functions help you work with numerical data efficiently. Here are some key functions:

round(), floor(), ceil(): Functions for rounding numbers to the nearest integer, down, or up respectively.
Example: Math.round(4.7) returns 5.

abs(): Returns the absolute value of a number.
Example: Math.abs(-5) returns 5.

format(): Formats a number according to specified locale and options.
Example: (1234567.89).toLocaleString('en-US') returns '1,234,567.89'.

These functions are crucial for financial calculations, data formatting, and ensuring numerical data is presented accurately.

Array Functions

Array functions allow you to manage collections of items effectively. Key functions include:

length (parameter): Returns the number of elements in an array.
Example: ['apple', 'banana', 'cherry'].length returns 3.

map(): Creates a new array with the results of calling a provided function on every element in the original array.
Example: [1, 2, 3].map(x => x * 2) returns [2, 4, 6].

filter(): Creates a new array with all elements that pass the test implemented by the provided function.
Example: [1, 2, 3, 4].filter(x => x > 2) returns [3, 4].

These functions are powerful for transforming and selecting elements within arrays, making them indispensable for data manipulation and analysis.

Object Functions

Object functions are used for handling key-value pairs. Important functions include:

keys(): Returns an array of the object's property names (keys).
Example: Object.keys({a: 1, b: 2}) returns ['a', 'b'].

values(): Returns an array of the object's property values.
Example: Object.values({a: 1, b: 2}) returns [1, 2].

hasField(): Checks if an object contains a specific property (key).
Example: 'a' in {a: 1, b: 2} returns true.

These functions are essential for accessing and manipulating object properties, allowing you to work with complex data structures efficiently.

Boolean Functions

Boolean functions are used for logical operations. Key functions include:

toNumber(): Converts a boolean true to 1 and false to 0.
Example: Number(true) returns 1.

toString(): Converts a boolean value to its string representation ("true" or "false").
Example: true.toString() returns 'true'.

Boolean functions are crucial for decision-making processes and controlling the flow of logic in your workflows.

DateTime Functions

n8n leverages the Luxon library for datetime functions, which are vital for date and time manipulation:

toDateTime(): Converts a string into a Luxon DateTime object.
Example: DateTime.fromISO('2021-09-30').toLocaleString() returns '9/30/2021'.

plus(), minus(): Perform calculations on dates, such as adding or subtracting days.
Example: DateTime.local().plus({days: 1}) returns the date for tomorrow.

format(): Formats a DateTime object into a string representation.
Example: DateTime.local().toFormat('DD') returns '09/30/2021'.

These functions are particularly useful for scheduling workflows and processing time-sensitive data.

Practical Applications and Best Practices

When using n8n JavaScript functions, consider the following best practices:

Utilize real-time feedback: Use the result panel in the function editor to instantly see the output and debug expressions.

Be aware of zero-based indexing: Remember that strings and arrays start counting from index 0.

Use single quotes for strings: To avoid issues with nested double quotes, use single quotes within the function editor.

These tips will help you avoid common pitfalls and make the most of n8n's capabilities.

Conclusion

By now, you should have a comprehensive understanding of every n8n JavaScript function. This knowledge empowers you to manipulate and transform data within your workflows effectively. Remember, the key to mastering these functions is practice and thoughtful application. As you integrate these skills into your daily work, you'll find that your workflow efficiency and speed improve significantly. Keep exploring and experimenting with these functions to unlock their full potential in your automation projects.

Podcast

Frequently Asked Questions

Welcome to the comprehensive FAQ section for the 'Video Course: Every N8N JavaScript Function Explained.' This resource is crafted to help you navigate through the course content, providing clarity on JavaScript functions within n8n, and offering insights into their practical applications. Whether you're a beginner or an experienced user, these FAQs are designed to enhance your understanding and proficiency in using n8n for workflow automation.

How many JavaScript functions are available in n8n, and what are the main categories?

As of the recording of the source material, there are 106 JavaScript functions available within n8n. These functions are broadly categorized into the following groups: string functions (for manipulating text), number functions (for working with numerical data), array functions (for managing collections of items), object functions (for handling key-value pairs), and Boolean functions (for logical operations).

What is the purpose of the "Edit Fields" node in n8n, and how does it relate to using JavaScript functions?

The "Edit Fields" node in n8n serves as a versatile tool for manipulating data within a workflow. It allows users to set variables, rename fields, and generally transform data structures. When using JavaScript functions, the "Edit Fields" node is often employed to access and modify data from previous nodes or to introduce example data for testing functions. It offers modes like manual mapping and JSON input to define and structure the data that the functions will operate on.

How are JavaScript functions accessed and used within n8n workflows?

JavaScript functions in n8n are typically accessed within the value field of a node (such as the "Edit Fields" node) after selecting a variable from a preceding node. Once a variable is selected and highlighted (often turning green), clicking a period (.) will open a function editor. This editor presents a list of available functions, categorized by their type (string, number, array, etc.). Users can then select a function and, if required, provide any necessary parameters within parentheses following the function name.

Which string manipulation functions in n8n are highlighted as being particularly useful and frequently used?

Several string manipulation functions are particularly useful and frequently employed. These include:

• split(): Used to convert a string into an array of substrings based on a specified delimiter.
• includes(): Checks if a string contains a specific substring.
• replace all(): Allows for the replacement of all occurrences of a substring within a string with another substring.
• length: A parameter (not technically a function with brackets) that returns the number of characters in a string.
• Extract functions (extract domain(), extract email(), extract URL(), extract URL paths()): Used to pull specific components from strings that contain domains, email addresses, or URLs.

Can you explain the purpose and usage of the map and filter functions when working with arrays in n8n?

The map and filter functions are powerful tools for transforming and selecting elements within arrays.

• map(): Iterates over each element in an array and applies a provided function to it, returning a new array with the results of that function applied to each element. This is useful for performing the same operation on multiple items in an array, such as modifying a property or concatenating a string to each element.
• filter(): Iterates over each element in an array and applies a provided function (a condition) to it. It returns a new array containing only the elements for which the function returns true. This is used to select specific items from an array based on certain criteria, such as items with a length greater than a certain value or items matching a specific pattern. Both functions often utilize arrow function syntax in JavaScript to define the operation or condition.

What are some common use cases for the datetime functions available in n8n?

Datetime functions in n8n (leveraging the Luxon library) are frequently used for a variety of tasks, including:

• Formatting dates and times into different string representations using the format() function, catering to various regional standards or application requirements.
• Performing calculations on dates, such as adding or subtracting days, weeks, months, or years using plus() and minus().
• Calculating the difference between two dates in various units (days, weeks, minutes, etc.) using diff 2().
• Extracting specific components of a date, such as the month, day, or year.
• Determining the start or end of a specific time period (e.g., start of month, end of year) using functions like start of() and end of().
• Identifying if a given date falls on a weekend using is weekend(). These functions are particularly useful for scheduling workflows, processing time-sensitive data, and integrating with services that require specific date and time formats.

How does n8n handle the conversion between different data types (e.g., string to number, string to Boolean)?

n8n provides specific JavaScript functions to explicitly convert data between different types. For instance:

• toNumber(): Converts a string that represents a number into an actual numerical data type, allowing for mathematical operations.
• toBoolean(): Converts a value (such as the strings "1" or "0") into a Boolean value (true or false).
• toString(): Converts a number or a Boolean value into its string representation, which is necessary for string manipulation or concatenation.
• parseJson(): Converts a string formatted as a JSON object into an actual JavaScript object, allowing for easy access to its key-value pairs. These conversion functions are crucial for ensuring that data is in the correct format for subsequent operations or integrations.

What are some key considerations or "hacks" mentioned for working effectively with JavaScript functions in n8n?

Several key considerations and "hacks" are highlighted:

• Utilizing the real-time feedback in the result panel when manipulating functions to instantly see the output and debug expressions.
• Being aware of the zero-based indexing when working with strings and arrays (the first element is at index 0).
• Understanding that array functions like includes() perform exact matching of array elements.
• Using single quotes as an alternative to double quotes when defining strings within the function editor to avoid issues with nested double quotes, and leveraging the quote() function for automatic escaping of quotes when necessary for specific data formats like JSON or SQL.
• Recognizing that parameters like length for strings are not functions (they don't have parentheses).
• Leveraging online tools like Regex101 to help build and test regular expressions for use with functions like match() and search().
• Understanding that datetime manipulations often require converting a string into a Luxon datetime object first using toDateTime().
• Being mindful of potential editor quirks, such as issues arising from trailing commas in function parameters.

Explain the purpose of the "Edit Fields" node in n8n and provide a scenario where you might use it.

The "Edit Fields" node in n8n allows you to manipulate the data structure of your workflow items. It can be used to set new variables, rename existing fields, and modify their values. For example, you might use it to combine the "firstName" and "lastName" fields from an incoming webhook into a single "fullName" field.

Describe the functionality of the split() string function and give an example of how it can be used to manipulate text data.

The split() string function divides a string into an array of substrings based on a specified delimiter. For example, if you have the string "apple,banana,cherry" and you use .split(','), it will return an array: ["apple", "banana", "cherry"].

What is the difference between the includes() and startsWith() string functions? Provide a brief example for each.

The includes() function checks if a string contains a specific substring and returns a boolean (true or false). For example, "hello".includes("ell") would return true. The startsWith() function checks if a string begins with a specific prefix and also returns a boolean. For example, "hello".startsWith("hel") would return true.

Explain how the replace all() string function works and describe a situation where it would be beneficial.

The replace all() string function finds all occurrences of a specified substring within a string and replaces them with another specified substring. This is useful for standardizing data, such as replacing all instances of "http://" with "https://" in a list of URLs.

What does the concat() string function do, and how does it differ from simply placing two strings next to each other in an expression?

The concat() string function joins one or more strings together. While placing two strings next to each other in an expression might seem similar, concat() can explicitly handle multiple strings or even an array of strings, providing a more structured way to combine text. For instance, "Hello".concat(" ", "world") explicitly joins the three strings.

Describe the purpose of the extract domain() and extract email() string functions. Give a brief example of when you might use each.

The extract domain() string function attempts to isolate and return the domain name from a given string that might contain a URL or email. For example, extract domain("https://www.example.com/page") would return "example.com". The extract email() string function tries to find and return an email address present within a string. For example, extract email("Contact us at info@example.co.uk for more details.") might return "info@example.co.uk".

Explain the concept of Base64 encoding and decoding. Why might you need to use base64Encode() or base64Decode() in an n8n workflow?

Base64 encoding is a process of converting binary data into an ASCII string format by translating it into a base-64 representation. Base64 decoding reverses this process, converting a Base64 encoded string back to its original binary data. You might need to use these functions in n8n when interacting with APIs or web services that require data, such as API keys or credentials, to be transmitted in Base64 encoded format for security or compatibility reasons.

How does the length property differ when used with a string versus an array in n8n?

When used with a string, the length property returns the number of characters in that string. When used with an array, the length property returns the number of elements within that array.

Describe the functionality of the append() array function and provide an example of adding a new element to an existing array.

The append() array function adds one or more new elements to the end of an existing array. For example, if you have an array ["apple", "banana"] and you use .append("cherry"), the array will become ["apple", "banana", "cherry"].

Explain the purpose of the map() array function and provide a simple example of how it can be used to transform the elements of an array.

The map() array function iterates over each element in an array and applies a provided function to each element, returning a new array with the results of those function calls. For example, if you have an array [1, 2, 3] and you use .map(item => item * 2), it will return a new array [2, 4, 6].

Discuss the importance of string manipulation functions in n8n for automating workflows. Provide specific examples of how functions like split(), replace all(), and concat() can be used to process and transform textual data in real-world scenarios.

String manipulation functions in n8n are crucial for automating workflows because they allow for dynamic data processing and transformation. For instance, the split() function can break down a CSV string into an array of values for further processing. The replace all() function is invaluable for cleaning data, such as updating outdated URLs or correcting common typos. The concat() function is used to build strings dynamically, such as creating personalized messages by combining user names with template text. These functions enable efficient data handling, essential for integrating various systems and automating repetitive tasks.

Explain the role of array functions in n8n for handling collections of data. Compare and contrast the functionalities of map(), filter(), and reduce(), illustrating their applications with practical examples of data transformation and analysis within an automation workflow.

Array functions in n8n are fundamental for managing and transforming collections of data. The map() function applies a transformation to each element in an array, returning a new array with the transformed data, such as converting an array of numbers to their squared values. The filter() function selects elements that meet a specific condition, like filtering out inactive users from a list. The reduce() function aggregates array elements into a single value, such as calculating the total sales from an array of transaction amounts. These functions enable complex data manipulation and analysis, essential for creating efficient and effective automation workflows.

Describe the utility of the various validation functions available in n8n, such as is domain(), is email(), and is numeric(). Discuss how incorporating these functions into your workflows can enhance data quality and prevent errors in automated processes.

Validation functions in n8n, such as is domain(), is email(), and is numeric(), are essential for ensuring data integrity and quality within workflows. These functions allow you to check whether data conforms to expected formats. For example, is email() can verify if a string is a valid email address before sending a notification, preventing errors and ensuring successful communication. Similarly, is numeric() can confirm that a value is a number before performing calculations, avoiding runtime errors. By incorporating these validation checks, you can build more robust workflows that handle data reliably and reduce the risk of processing invalid or unexpected data.

Explain the significance of date and time manipulation functions in n8n, particularly the use of the Luxon library. Provide examples of how functions like format(), plus(), minus(), and diff 2() can be used to automate tasks involving scheduling, deadlines, and time-based data processing.

Date and time manipulation functions in n8n, enhanced by the Luxon library, are crucial for automating tasks that involve scheduling and deadlines. The format() function allows you to convert dates into human-readable strings, suitable for reports and notifications. The plus() and minus() functions enable you to calculate future or past dates, such as setting a reminder two weeks from today. The diff 2() function calculates the time difference between two dates, useful for tracking project timelines. These functions help automate time-sensitive workflows, ensuring tasks are executed at the right time and deadlines are met.

Discuss how the different categories of n8n functions (string, number, array, object, boolean) contribute to building robust and versatile automation workflows. Illustrate with a comprehensive scenario that demonstrates the integration of functions from multiple categories to achieve a specific automation goal.

The different categories of n8n functions—string, number, array, object, and boolean—each play a vital role in building robust automation workflows. For instance, in a scenario where you need to process customer orders, you might use string functions to clean and format customer names, number functions to calculate order totals, array functions to handle lists of items, object functions to structure order data, and boolean functions to apply conditional logic for order validation. By integrating these functions, you can create a comprehensive workflow that automates order processing from start to finish, ensuring accuracy and efficiency.

What are some potential challenges or obstacles when using JavaScript functions in n8n, and how can they be overcome?

One potential challenge when using JavaScript functions in n8n is handling unexpected data formats, which can lead to errors. To overcome this, it's essential to implement data validation and error handling within your workflows. Another challenge is dealing with complex data transformations, which may require chaining multiple functions together. This can be addressed by breaking down transformations into smaller, manageable steps and using the real-time feedback feature to test and debug expressions. Additionally, understanding zero-based indexing and the nuances of JavaScript syntax is crucial for avoiding common pitfalls.

What are some practical applications of using n8n JavaScript functions in business workflows?

n8n JavaScript functions can be applied in various business workflows to enhance efficiency and automation. For example, they can be used to clean and format data received from forms, ensuring consistency before it is stored in a database. They can also automate email notifications by extracting relevant information and formatting it into personalized messages. In e-commerce, these functions can calculate order totals and apply discounts dynamically. Additionally, they can be used for data analysis, such as aggregating sales data and generating reports, enabling businesses to make data-driven decisions.

What are some common misconceptions about using JavaScript functions in n8n?

A common misconception is that using JavaScript functions in n8n requires extensive programming knowledge. While familiarity with JavaScript is beneficial, n8n's user-friendly interface and function editor make it accessible for users with basic coding skills. Another misconception is that these functions are limited in scope; however, they offer a wide range of capabilities, from simple data transformations to complex logic. Additionally, some users may believe that n8n functions are only suitable for technical tasks, but they are versatile enough to automate business processes across various domains.

What are some advanced usage tips for leveraging JavaScript functions in n8n?

For advanced usage of JavaScript functions in n8n, consider utilizing custom functions to encapsulate complex logic that can be reused across workflows. Additionally, take advantage of regular expressions for sophisticated text processing tasks. Integrating external libraries via the function editor can extend functionality beyond built-in capabilities. Understanding asynchronous operations and using promises can also enhance your workflows, especially when dealing with API calls. Finally, leveraging conditional logic with boolean functions can create dynamic workflows that adapt to varying input conditions.