如何在 JavaScript 中用“下划线”（“_”）替换 80% 的字符串？

Posted 2023-03-08

【中文标题】如何在 JavaScript 中用“下划线”（“_”）替换 80% 的字符串？

【英文标题】：How to substitute 80% of a string with "underscore" ( " _ " ) in JavaScript?

【发布时间】：2019-06-23 16:11:16

【问题描述】：

我的代码中有一个字符串。我想删除 80% 的字符串字母并将它们替换为“_”（下划线）。

我已经设法用“_”替换了所有字符串字符，但我不能让它只替换我字符串的 80%。

var a = "mystring";
var splitted = a.split('');

var count = 0;
while(count < a.length) 
    if(splitted[count] !== '_' && splitted[count] !== ' ') 
        splitted[count] = '_ ';
        count++;
     
 

console.log(splitted);

代码输出：_ _ _ _ _ _ _ _ 所需输出：_ y _ _ _ _ _ _ 或：_ _ s _ _ _ _ _ 或：_ _ _ _ _ i _

【问题讨论】：

在您的代码中看不到 80 或 0,8。您尝试过什么来实现这一目标？

developer.mozilla.org/en-US/docs/Web/javascript/Reference/… 或 developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

实际上预期的结果是替换 87.5% 的字符串：对于长度为 9 或 10 的单词应该发生什么？

实际上 80% 表示 5 个字符中的 4 个。因此，对于每 5 个字符，下划线 4 个字符并显示可能是第一个或最后一个的 1。

我相信你应该计算一下每个字符串这个 80% 有多少个符号，并在 char-replace-loop 中使用它，以便在转换为下划线时不要超过这个数字;)

【参考方案1】：

我创建了一个通用方法来满足您的需求。它基于Set的生成 这将包含将被替换的索引（随机生成）的N%。然后，我们使用replace() 的replacement 函数来检查每次迭代是否需要替换token，基本上检查要替换的字符的当前索引是否在前面提到的@987654326 @。

const replace = (str, token, percentage) =>

    // Get the quantity of characters to be replaced.

    var numToReplace = Math.floor(str.length * percentage);

    // Generate a set of random indexes to be replaced.

    var idxsToReplace = new Set();

    while (idxsToReplace.size < numToReplace)
    
        idxsToReplace.add(Math.floor(Math.random() * str.length));
    

    // Do the replacement of characters:

    return str.replace(/./g, (x, offset) => idxsToReplace.has(offset) ? token : x);


console.log(replace("mystring", "_", 0.8));
console.log(replace("mystring", "+", 0.5));
console.log(replace("Hello World", "#", 0.7));

【参考方案2】：

如果要替换 80% 的字符串，则需要搜索单词的所有长度，然后乘以 0.8，然后执行 while 替换随机字母。

     var string = 'mystring';
        var splitted = string.split('');
        var percent = Math.round(splitted.length * 0.8);
        var changues =0;

        while (changues<percent)
            var random = Math.floor((Math.random() * splitted.length ) + 0);
            if(splitted[random]!='_')
                splitted[random]='_';
                changues++;
            

        
        string=splitted.join('');
        console.log(string);

【讨论】：

这解决了我想要的问题。感谢所有其他答案。他们也工作。感谢 Stack Overflow 社区。​​span>

【参考方案3】：

您可以通过检查随机值来替换单个字符。

var string = "mystring",
    replaced = string.replace(/./g, c => Math.random() < 0.8 ? '_' : c);
    
console.log(replaced);

【讨论】：

这种方法使任何字符都有 80% 的概率被替换，因此这可能导致所有字符都被替换，或者以非常低的概率没有字符被替换。这是一种优雅的方法，但是我认为 OP 希望替换字符的 80% 并保持其余部分不变

【参考方案4】：

    String.prototype.replaceAt = function(index, replacement) 
        return this.substr(0, index) + replacement + this.substr(index + replacement.length);
    

    var a = "mystring";
    var len = a.length;
    var x = len * 0.8;
    var ceil= Math.ceil(x);
    var i;
    var used = [];

    for (i = 0; i < ceil; i++) 
        var exist = true;
        while (exist) 
            var index = Math.floor(Math.random() * len);
            exist = used.includes(index);
        
        a = a.replaceAt(index, '_');
        used.push(index);
    
 console.log(a);

【参考方案5】：

您可以先替换所有字母，然后计算字母的数量以恢复原始。

function replace(string, percent) 
  let re = string.replace(/\S/g, '_').split('')
  let len = string.replace(/ /g, '').length
  let count = len - Math.ceil(len * percent)
  while (count) 
    let int = Math.floor(Math.random() * string.length)
    if (re[int] != ' ' && re[int] == '_') 
      re[int] = string[int]
      count--
    
  

  return re.join('')


console.log(replace("mystring lorem", 0.8))
console.log(replace("mystring", 0.8))
console.log(replace("Lorem ipsum dolor sit amet.", 0.2))

【参考方案6】：

这是我能想到的最接近的简单解决方案。它会以一定的概率隐藏字母。假设你想以“80% 的概率”隐藏字母，那么它就是这样完成的。当然它不会每次都隐藏 80% 的字母：

const hideLetters = (str = '', probability = 1, mask = '_') => 
  return str
    .split('')
    .map((letter, i) => (Math.random() >= probability) ? letter : mask)
    .join('');


console.log(hideLetters('mystring', 0.8));
console.log(hideLetters('password', 0.5, '*'));

【讨论】：

您可以将模式str.split('').map(cb) 组合到Array.from(str, cb))，因为实现了Symbol.iterator，字符串是可扩展的。

如果你想确保它替换了 80% 的字符，你可以首先构建一个随机的、非重复位置的数组（更好的是 Set()）来替换，其中 80%字符串的大小，然后使用它来进行替换。或者可能首先构建一个顺序位置数组，删除其中的 20%，然后使用它来知道要替换字符串上的哪些位置。