如何基于字符串列表数组动态查找indexof并截取字符串？

Hey there! Let's dive into your two technical requirements and work through practical, adaptable solutions— I’ll use JavaScript for examples since you mentioned indexOf, but the logic translates easily to other languages like Python or Java too.

If you’re looking to dynamically find the index of a target string within an array (with flexibility beyond the native strict indexOf), a reusable function is your best bet. Here’s a robust implementation that handles common edge cases like case insensitivity:

function getDynamicStringIndex(stringArray, target, caseSensitive = true) {
  // Normalize target and array elements if case-insensitive is enabled
  const normalizedTarget = caseSensitive ? target : target.toLowerCase();
  
  return stringArray.findIndex(str => {
    const normalizedStr = caseSensitive ? str : str.toLowerCase();
    return normalizedStr === normalizedTarget;
  });
}

// Example usage
const fruitArray = ["Mango", "Pineapple", "Kiwi"];
console.log(getDynamicStringIndex(fruitArray, "kiwi", false)); // Output: 2
console.log(getDynamicStringIndex(fruitArray, "Orange")); // Output: -1 (not found)

This function lets you pass any array and target string, with an optional flag to toggle case sensitivity—way more flexible than the native array.indexOf() which only does strict matches. If you need partial matches (e.g., find any string containing the target), you can swap === with includes() instead.

Since you mentioned you have a sample array and a clear desired output, let’s assume your sample follows a consistent pattern (e.g., ["user_123_profile", "user_456_settings", "user_789_notifications"] needing to become ["123", "456", "789"]).

Two reliable approaches here:

Option 1: Regex Matching (Best for Structured Patterns) #

If your strings follow a predictable format, regex lets you extract exactly the part you need:

function truncateWithRegex(sampleArray, captureRegex) {
  return sampleArray.map(str => {
    const match = str.match(captureRegex);
    // Return captured group if match exists, else original string as fallback
    return match ? match[1] : str;
  });
}

// Example: Extract the numeric ID from "user_{ID}_{type}"
const sampleUsers = ["user_123_profile", "user_456_settings", "user_789_notifications"];
const truncatedIds = truncateWithRegex(sampleUsers, /user_(\d+)_/);
console.log(truncatedIds); // Output: ["123", "456", "789"]

Option 2: Split & Slice (Best for Simple Delimiters) #

If your strings use consistent delimiters (like underscores or hyphens), splitting the string and picking the right index works perfectly:

function truncateWithSplit(sampleArray, delimiter, targetIndex) {
  return sampleArray.map(str => str.split(delimiter)[targetIndex]);
}

// Same example as above, using underscore delimiter and index 1
const truncatedIdsSplit = truncateWithSplit(sampleUsers, "_", 1);
console.log(truncatedIdsSplit); // Output: ["123", "456", "789"]

Quick Note #

If your sample array has inconsistent formatting, you might need to add error handling (e.g., check if the split array has the target index, or if the regex matches before accessing groups).

Feel free to share your specific sample array and desired output, or your existing implementation—we can refine this further to fit your exact use case!

内容的提问来源于stack exchange，提问作者Muhaimin CS