问如果前者是后者的一部分，那么如何安全地将每个搜索替换为一个替换项，而不需要再次替换这样的搜索？

EN

const text = "Please click on dashboard and then open the dashboard details to verify your details on the data or the other data";
const tokens = ["dashboard", "dashboard", "data", "data"]
const links = ["https://abcd.com/login", "https://abcd.com/home", "https://abcd.com/data", "https://abcd.com/dashboard/data"]

var result = text;

for (i = 0; i < tokens.length; i++) {
  const re = new RegExp('(?<=.*)((?<= )' + tokens[i] + '(?= |$))(?=.*)');
  result = result.replace(re, '<a href="' + links[i] + '">$&</a>'); //TODO array length validation
}

console.log(result)

var string = "Please click on dashboard and then open the dashboard details to verify your details on the data";
const stringArray = string.split(' ');
var targetTexts = ["dashboard" , "dashboard" , "data"]
var replaceTexts = ["https://abcd.com/login" , "https://abcd.com/home" , "https://abcd.com/data"]

const resultArray = []
for (let i = 0; i < stringArray.length; i++) {
  const word = stringArray[i];
  const targetTextIndex = targetTexts.indexOf(word);
  
  if (targetTextIndex > -1) {
    resultArray.push("<a href='"+replaceTexts[targetTextIndex]+"'>"+word+"</a>")
    targetTexts = targetTexts.filter((_el, idx) => idx !== targetTextIndex)
    replaceTexts = replaceTexts.filter((_el, idx) => idx !== targetTextIndex)

  } else {
    resultArray.push(word);
  }
}

console.log(resultArray.join(' '))

function createReplacementItemFromBoundHrefs(search, idx) {
  const hrefList = this;
  return {
    search,
    href: hrefList[idx],
  }
}
function aggregateSafelyReplacedHrefPartials(partials, { search, href }) {
  // intentionally mutates `partials`, an array of zero to many
  // processed substrings and always an unprocessed (last item)
  // `target` substring of the originally provided string value.
  const target = partials.pop();

  let sliceAt;
  const result = target
    .replace(

      // a case insensitive search regex.
      RegExp(`${ search }`, 'i'),

      // a replacer function which helps preventing multiple
      // manipulations of always the same search/replace term.
      (match, offset) => {
        const replacement = `<a href="${ href }">${ match }</a>`;

        sliceAt = offset + replacement.length;

        return replacement;
      },
    );

  return [
    ...partials,              // - processed lately.
    result.slice(0, sliceAt), // - processed latest.
    result.slice(sliceAt),    // - to be processed.
  ];
}

function safelyReplaceSearchWithRelatedHref(str, searchList, hrefList) {
  return searchList
    .map(createReplacementItemFromBoundHrefs, hrefList)
    .reduce(aggregateSafelyReplacedHrefPartials, [str])
    .join('');
}

const string = "Please click on dashboard and then open the dashboard details to verify your details on the data";

const stringArray = [
  "dashboard",
  "dashboard",
  "data",
];
const replaceArray = [
  "https://abcd.com/login",
  "https://abcd.com/home",
  "https://abcd.com/data",
];

console.log(
  'before ... ',
  string,
  '\n\nafter ... ',
  safelyReplaceSearchWithRelatedHref(string, stringArray, replaceArray),
);
console.log(
  stringArray
    .map(createReplacementItemFromBoundHrefs, replaceArray) 
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

- a case insensitive regex which features any possible word/search ... and ...
- a [replacer function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#parameters) which keeps track of each search's occurrence and upon a search's current occurrence count decides whether to really replace a search by its related full hypertext reference or just with itself (its very own match).

function aggregateReplacementTrackerFromBoundData(collector, search, idx) {
  const { occurrences = [], hrefList = [], tracker = {} } = collector;

  // create and/or access and aggregate
  // a search specific occurrence tracker.
  (tracker[search.toLowerCase()] ??= {
    occurrence: {},
    occurrenceCount: 0,
  })
  .occurrence[ occurrences[idx] ] = hrefList[idx];

  return { occurrences, hrefList, tracker };
}
function safelyReplaceSearchOccurrencesWithRelatedHref(
  str, searchList, hrefList, occurrences,
) {
  // create an overall replacement tracker for any search.
  const { tracker } = searchList
    .reduce(aggregateReplacementTrackerFromBoundData, {
      occurrences,
      hrefList,
      tracker: {},
    });

  return str
    .replace(

      // a case insensitive regex which features any possible word/search.
      RegExp(`\\b(?:${ searchList.join('|') })\\b`, 'gi'),

      // a replacer function which keeps track of each search's occurrence
      // and upon a search's current occurrence count decides whether to
      // really replace a search by its related full hypertext reference
      // or just with itself (its very own match).
      (match/*, offset, target*/) => {
        const searchTracker = tracker[match.toLowerCase()];

        const count = ++searchTracker.occurrenceCount;
        const href = searchTracker.occurrence[count] ?? null;

        return (href !== null)
          && `<a href="${ href }">${ match }</a>`
          || match;
      },
    );
}

const string = "On dashboard, then open dashboard details, verify your dashboard details on data and other data";

const wordsArray = [
  "dashboard",
  "dashboard",
  "data",
];
const occurrences = [1 , 3 , 2];

const linksArray = [
  "https://abcd.com/login",
  "https://abcd.com/home",
  "https://abcd.com/data",
];

console.log(
  'before ... ',
  string,
  '\n\nafter ... ',
  safelyReplaceSearchOccurrencesWithRelatedHref(
    string, wordsArray, linksArray, occurrences,
  ),
);
console.log({
  replacementTracker: wordsArray
    .reduce(aggregateReplacementTrackerFromBoundData, {
      occurrences,
      hrefList: linksArray,
      tracker: {},
    })
    .tracker
});

.as-console-wrapper { min-height: 100%!important; top: 0; }