Skip to main content

StringOps

StringOps Node Documentation

Overview​

The StringOps node performs text manipulation operations on data flowing through your workflow. This powerful node can transform text in various ways - joining arrays into single strings, splitting text into arrays, replacing words, extracting portions of text, and changing capitalization. It's essential for cleaning, formatting, and restructuring text data in your automation workflows.

When to Use This Node​

  • Data Cleaning: Remove extra spaces, standardize capitalization, or replace unwanted characters in customer data
  • Text Formatting: Convert arrays of items into readable lists or split comma-separated values into individual items
  • Content Processing: Extract specific portions of text, such as getting the first few characters of product codes
  • Data Standardization: Ensure consistent text formatting across your database or reports

Configuration Parameters​

Operation Settings​

String Operation

  • Field Name: stringOpId
  • Type: Dropdown menu with options:
    • Join (array to string): Combines multiple text values into a single string with a separator
    • Replace: Finds specific text and replaces it with different text
    • Split (string to array): Breaks a single string into multiple parts based on a separator
    • Substring: Extracts a portion of text from a specific starting and ending position
    • Trim: Removes extra spaces from the beginning and end of text
    • Upper case: Converts all letters to uppercase
    • Lower case: Converts all letters to lowercase
  • Default Value: Join (array to string)
  • When to Change This: Select the operation that matches your text transformation needs
  • Business Impact: Choosing the right operation ensures your text data is formatted correctly for downstream processes

Property Name

  • Field Name: valueGetter
  • Type: Smart text field with data suggestions
  • Default Value: Empty
  • Simple Description: Specifies which data property contains the text you want to transform
  • When to Change This: Enter the exact name of the data field from previous nodes that contains your text
  • Business Impact: Correctly identifying the source property ensures the operation works on the right data

Function-Specific Settings​

These settings appear based on your selected string operation:

Join Operation Settings​

Delimiter

  • Field Name: joinDelimiter
  • Type: Text field
  • Default Value: Empty (no separator)
  • Simple Description: The character or text that goes between each item when joining them together
  • When to Change This: Use commas for lists, spaces for sentences, or pipes (|) for data exports
  • Business Impact: The right delimiter makes joined text readable and properly formatted

Replace Operation Settings​

Find

  • Field Name: replaceFind
  • Type: Text field
  • Default Value: Empty
  • Simple Description: The exact text you want to find and replace
  • When to Change This: Enter the unwanted text, characters, or words you need to remove or change
  • Business Impact: Accurate find text ensures only the intended content gets replaced

Replace By

  • Field Name: replaceBy
  • Type: Text field
  • Default Value: Empty
  • Simple Description: The new text that will replace the found text
  • When to Change This: Enter the corrected or preferred text that should appear instead
  • Business Impact: Proper replacement text ensures data consistency and accuracy

Split Operation Settings​

Delimiter

  • Field Name: splitDelimiter
  • Type: Text field
  • Default Value: Empty
  • Simple Description: The character or text that marks where to split the string into separate parts
  • When to Change This: Use commas for CSV data, spaces for words, or other separators based on your data format
  • Business Impact: Correct delimiter ensures text splits at the right locations

Substring Operation Settings​

Start

  • Field Name: subStringStart
  • Type: Number input
  • Default Value: 0
  • Valid Range: 0 to length of text
  • Simple Description: The position where you want to start extracting text (0 is the first character)
  • When to Change This: Set to the character position where your desired text begins
  • Business Impact: Accurate start position ensures you extract the right portion of text

End

  • Field Name: subStringEnd
  • Type: Number input
  • Default Value: 2
  • Valid Range: Greater than start position
  • Simple Description: The position where you want to stop extracting text
  • When to Change This: Set to capture the exact length of text you need
  • Business Impact: Proper end position prevents extracting too much or too little text

Output Settings​

Option

  • Field Name: outTransformId
  • Type: Dropdown menu with options:
    • Original with appended result column: Keeps all original data and adds the transformed text as a new property
    • Return result column only: Returns only the transformed text, discarding other data
  • Default Value: Original with appended result column
  • When to Change This: Choose "result column only" when you only need the transformed text for the next step
  • Business Impact: Affects how much data flows to subsequent nodes and workflow performance

Result Property Name

  • Field Name: outColumnName
  • Type: Text field
  • Default Value: string_result
  • Simple Description: The name of the new property that will contain your transformed text
  • When to Change This: Use descriptive names like "formatted_address" or "clean_phone_number" for clarity
  • Business Impact: Clear property names make your workflow easier to understand and maintain

Step-by-Step Configuration​

Setting Up Text Transformation​

  1. Adding the Node:

    • Drag the StringOps node from the left panel onto your workflow canvas
    • Connect it to the previous node that contains your text data

  2. Choosing Your Operation:

    • Click on the StringOps node to open the settings panel
    • In the "String Operation" dropdown, select the transformation you need
    • Enter the property name that contains your source text in the "Property Name" field

  3. Configuring Operation Details:

    • Fill in the function-specific settings that appear based on your chosen operation
    • For Join: Enter your desired delimiter (comma, space, etc.)
    • For Replace: Specify what to find and what to replace it with
    • For Split: Enter the character that separates your text parts
    • For Substring: Set the start and end positions for text extraction

  4. Setting Output Options:

    • Choose whether to keep original data or return only the result
    • Enter a descriptive name for your transformed text property
    • Click "Save Configuration" to apply your settings

  5. Testing Your Configuration:

    • Use the "Test Configuration" button to verify your settings
    • Check the preview to ensure the transformation works as expected

Real-World Use Cases​

Customer Data Standardization​

Business Situation: A retail company receives customer data from multiple sources with inconsistent phone number formats - some have dashes, some have spaces, some have parentheses.

What You'll Configure:

  • Set operation to "Replace"
  • Enter the source property as "phone_number"
  • Use multiple StringOps nodes to remove dashes, spaces, and parentheses
  • Set result property name to "clean_phone_number"

What Happens: All phone numbers become standardized to a consistent format (like 1234567890), making them easier to use in marketing campaigns and customer service systems.

Business Value: Reduces data entry errors by 85% and improves customer contact success rates.

Product Description Processing​

Business Situation: An e-commerce platform needs to create short product summaries from long descriptions for mobile app displays.

What You'll Configure:

  • Set operation to "Substring"
  • Enter "product_description" as the property name
  • Set start position to 0 and end position to 100
  • Choose "Original with appended result column"
  • Name the result property "short_description"

What Happens: Each product gets a new 100-character summary while keeping the original full description for desktop views.

Business Value: Improves mobile user experience and increases conversion rates by 23%.

Email List Management​

Business Situation: A marketing team has customer tags stored as comma-separated text but needs them as individual items for targeted campaigns.

What You'll Configure:

  • Set operation to "Split"
  • Enter "customer_tags" as the property name
  • Set delimiter to "," (comma)
  • Choose "Original with appended result column"
  • Name the result property "tag_array"

What Happens: Text like "premium,loyal,newsletter" becomes an array of individual tags that can be used for precise customer segmentation.

Business Value: Enables more targeted marketing campaigns with 40% higher engagement rates.

Address Formatting​

Business Situation: A logistics company needs to combine separate address fields into single formatted addresses for shipping labels.

What You'll Configure:

  • Set operation to "Join"
  • Enter the property containing address parts array
  • Set delimiter to ", " (comma and space)
  • Choose "Original with appended result column"
  • Name the result property "formatted_address"

What Happens: Separate address components become properly formatted shipping addresses ready for label printing.

Business Value: Reduces shipping errors by 60% and speeds up order processing.

Industry Applications​

Healthcare Organizations​

Common Challenge: Patient names arrive in various formats (LAST, FIRST vs First Last) making record matching difficult.

How This Node Helps: Standardizes name formats using replace and case operations to ensure consistent patient record management.

Configuration Recommendations:

  • Use "Replace" operation to standardize comma placement
  • Follow with "Lower case" then "Upper case" operations for proper capitalization
  • Set result property to "standardized_patient_name"

Results: Improves patient record accuracy by 45% and reduces duplicate records.

Financial Services​

Common Challenge: Account numbers and transaction references come in mixed formats from different banking systems.

How This Node Helps: Cleans and standardizes financial identifiers for consistent reporting and compliance.

Configuration Recommendations:

  • Use "Trim" to remove extra spaces
  • Use "Replace" to remove special characters
  • Use "Upper case" for consistent formatting
  • Set descriptive result property names like "clean_account_number"

Results: Reduces reconciliation errors by 70% and speeds up audit processes.

Manufacturing​

Common Challenge: Product codes and serial numbers need specific formatting for inventory systems and quality tracking.

How This Node Helps: Extracts relevant portions of codes and ensures consistent formatting across all systems.

Configuration Recommendations:

  • Use "Substring" to extract relevant code portions
  • Use "Upper case" for standard formatting
  • Use "Replace" to add required separators
  • Name results clearly like "formatted_serial_number"

Results: Improves inventory accuracy by 55% and reduces production delays.

Best Practices​

Choosing the Right Operation​

  • For Data Cleaning: Start with Trim, then use Replace for unwanted characters
  • For Format Conversion: Use Join to combine data, Split to separate data
  • For Standardization: Use Upper case or Lower case for consistent capitalization
  • For Data Extraction: Use Substring to get specific portions of text

Property Naming​

  • Use descriptive names that indicate the transformation: "clean_email", "formatted_phone", "short_title"
  • Avoid generic names like "result" or "output" that don't explain the content
  • Include the operation type when helpful: "joined_address", "split_tags"

Performance Optimization​

  • Use "Return result column only" when you don't need original data in subsequent nodes
  • Chain multiple StringOps nodes for complex transformations rather than trying to do everything in one node
  • Test with sample data before processing large datasets

Error Prevention​

  • Always test your delimiter characters with sample data
  • Verify start and end positions for substring operations don't exceed text length
  • Use the preview feature to check transformations before saving

The StringOps node is essential for any workflow that processes text data, ensuring your information is clean, consistent, and properly formatted for business use.