web-dev-qa-db-fra.com

Couper le caractère spécifique d'une chaîne

Quel est le JavaScript équivalent à cette méthode C#:

var x = "|f|oo||"; 
var y = x.Trim('|'); //  "f|oo"

C # coupe le caractère sélectionné uniquement au début début et fin de la chaîne!

javascriptstringtrim
58
fubo

Une ligne suffit:

var x = '|f|oo||';
var y = x.replace(/^\|+|\|+$/g, '');
document.write(x + '<br />' + y);

^\|+   beginning of the string, pipe, one or more times
|      or
\|+$   pipe, one or more times, end of the string

Dans une fonction:

function trim (s, c) {
  if (c === "]") c = "\\]";
  if (c === "\\") c = "\\\\";
  return s.replace(new RegExp(
    "^[" + c + "]+|[" + c + "]+$", "g"
  ), "");
}

s = ".foo..oo...";
console.log(s, "->", trim(s, "."));
s = "|foo||oo|||";
console.log(s, "->", trim(s, "|"));
s = "]foo]]oo]]]";
console.log(s, "->", trim(s, "]"));
s = "\\foo\\\\oo\\\\\\";
console.log(s, "->", trim(s, "\\"));

74
leaf

Si j'ai bien compris, vous voulez supprimer un caractère spécifique uniquement s'il se trouve au début ou à la fin de la chaîne (ex: "|| fo || oo ||||" devrait devenir "foo || oo") . Vous pouvez créer une fonction ad hoc comme suit:

function trimChar(string, charToRemove) {
    while(string.charAt(0)==charToRemove) {
        string = string.substring(1);
    }

    while(string.charAt(string.length-1)==charToRemove) {
        string = string.substring(0,string.length-1);
    }

    return string;
}

J'ai testé cette fonction avec le code ci-dessous:

var str = "|f|oo||";
$( "#original" ).html( "Original String: '" + str + "'" );
$( "#trimmed" ).html( "Trimmed: '" + trimChar(str, "|") + "'" );
24
Pho3niX83

Vous pouvez utiliser une expression régulière telle que:

var x = "|f|oo||";
var y = x.replace(/^[\|]+|[\|]+$/g, "");
alert(y); // f|oo

METTRE À JOUR:

Si vous souhaitez généraliser ceci dans une fonction, vous pouvez faire ce qui suit:

var escapeRegExp = function(strToEscape) {
    // Escape special characters for use in a regular expression
    return strToEscape.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
};

var trimChar = function(origString, charToTrim) {
    charToTrim = escapeRegExp(charToTrim);
    var regEx = new RegExp("^[" + charToTrim + "]+|[" + charToTrim + "]+$", "g");
    return origString.replace(regEx, "");
};

var x = "|f|oo||";
var y = trimChar(x, "|");
alert(y); // f|oo
12
neelsg

pour garder cette question à jour: 

voici une approche que je choisirais par rapport à la fonction regex à l'aide de l'opérateur de propagation ES6. 

function trimByChar(string, character) {
  const first = [...string].findIndex(char => char !== character);
  const last = [...string].reverse().findIndex(char => char !== character);
  return string.substring(first, string.length - last);
}
11
Robin F.

Cela peut couper plusieurs personnages à la fois:

String.prototype.trimChars = function (c) {
  var re = new RegExp("^[" + c + "]+|[" + c + "]+$", "g");
  return this.replace(re,"");
}

var x = "|f|oo||"; 
x =  x.trimChars('|'); // f|oo

var y = "..++|f|oo||++..";
y = y.trimChars('|.+'); // f|oo

var z = "\\f|oo\\"; // \f|oo\

// For backslash, remember to double-escape:
z = z.trimChars("\\\\"); // f|oo
5
marlar

Celui-ci coupe tous les délimiteurs de début et de fin

const trim = (str, delimiter) => {
  const pattern = `[^\\${delimiter}]`;
  const start = str.search(pattern);
  const stop = str.length - str.split('').reverse().join('').search(pattern);
  return str.substring(start, stop);
}

const test = '||2|aaaa12bb3ccc|||||';
console.log(trim(test, '|')); // 2|aaaa12bb3ccc
1
Dmitriy Botov

À ma connaissance, jQuery n’a pas de fonction intégrée à la méthode sur laquelle vous vous interrogez . Cependant, avec javascript, vous pouvez simplement utiliser la méthode replace pour changer le contenu de votre chaîne:

x.replace(/|/i, ""));

Cela remplacera toutes les occurrences de | avec rien.

1
Ole Haugset

Une version sans regex facile à regarder:

const trim = (str, chars) => str.split(chars).filter(Boolean).join(chars);

Pour les cas d'utilisation où nous sommes certains qu'il n'y a pas de répétition des caractères sur les bords.

1
mbaer3000

Si vous avez affaire à des chaînes plus longues, je pense que cela devrait surpasser la plupart des autres options en réduisant le nombre de chaînes allouées à zéro ou à un:

function trim(str, ch) {
    var start = 0, 
        end = str.length;

    while(start < end && str[start] === ch)
        ++start;

    while(end > start && str[end - 1] === ch)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

// Usage:
trim('|hello|world|', '|'); // => 'hello|world'

Ou si vous souhaitez supprimer un ensemble de plusieurs caractères:

function trimAny(str, chars) {
    var start = 0, 
        end = str.length;

    while(start < end && chars.indexOf(str[start]) >= 0)
        ++start;

    while(end > start && chars.indexOf(str[end - 1]) >= 0)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

// Usage:
trimAny('|hello|world   ', [ '|', ' ' ]); // => 'hello|world'
// because '.indexOf' is used, you could also pass a string for the 2nd parameter:
trimAny('|hello| world  ', '| '); // => 'hello|world'
1
Jason Larke

J'aime la solution de @ Pho3niX83 ...

Etendons le avec "Word" au lieu de "char" ...

function trimWord(_string, _Word) {

    var splitted = _string.split(_Word);

    while (splitted.length && splitted[0] === "") {
        splitted.shift();
    }
    while (splitted.length && splitted[splitted.length - 1] === "") {
        splitted.pop();
    }
    return splitted.join(_Word);
};
0
foxontherock

essayer:

console.log(x.replace(/\|/g,''));
0
Man Programmer

en développant la réponse de @leaf, en voici une qui peut prendre plusieurs caractères: 

var trim = function (s, t) {
  var tr, sr
  tr = t.split('').map(e => `\\\\${e}`).join('')
  sr = s.replace(new RegExp(`^[${tr}]+|[${tr}]+$`, 'g'), '')
  return sr
}
0
AmitK
function trim(text, val) {
    return text.replace(new RegExp('^'+val+'+|'+val+'+$','g'), '');
}
0
Alexander Ladonin

Regex semble un peu trop complexe pour un problème simple comme Trim?

C #

var x = "|f|oo||"; 
var y = x.Trim('|'); //  "f|oo"

Javascript, exemple x.TrimLeft ('|') - simple (mais ne modifie qu'un seul caractère)

var ltrim = "|";
var x = "|f|oo||";
var y = (x.startsWith(ltrim) ? x.substring(ltrim.length) : x); //  "f|oo||"

var result = y;
console.log(y);

Exemple complet avec Javascript (grâce à @Tobo answer)

String.prototype.trimStart = function(delimiter) {
  if (!delimiter) {
    return this.replace(/^\s+/gm, '');
  }

  var current = this; var index = this.length;
  while(current.startsWith(delimiter) && index >= 0) {
      current = current.substring(delimiter.length);
      --index;
  }
  return current;
};

String.prototype.reverse = function() {
  return this.split("").reverse().join("");
}

String.prototype.trimEnd = function(delimiter) {
  if (!delimiter) {
    return this.reverse().replace(/^\s+/gm, '').reverse();
  }

  var current = this; var index = this.length;
  while(current.endsWith(delimiter) && index >= 0) {
      current = current.substring(0, this.length - delimiter.length - 1);
      --index;
  }
  return current;
};

String.prototype.trimString = function(delimiter) {
  if (!delimiter) {
    return this.trim();
  }

  return this.trimStart(delimiter).trimEnd(delimiter);
};

var str = "|f|oo||";
var strWhitespace = " |f|oo||  ";

console.log("/*" + str.trimStart("|") + "*/", "\"" + str + "\".trimStart(\"|\");");
console.log("/*" + str.trimEnd("|") + "*/", "\"" + str + "\".trimEnd(\"|\");");
console.log("/*" + str.trimString("|") + "*/", "\"" + str + "\".trimString(\"|\");");

console.log("/*" + strWhitespace.trimStart() + "*/", "\"" + strWhitespace + "\".trimStart();");
console.log("/*" + strWhitespace.trimEnd() + "*/", "\"" + strWhitespace + "\".trimEnd();");
console.log("/*" + strWhitespace.trimString() + "*/", "\"" + strWhitespace + "\".trimString();");

J'étais un peu paresseux avec trimStart et trimEnd. Il serait plus efficace de déterminer combien de chaque côté doit être réduit. Ensuite, appelez la sous-chaîne une seule fois. Mais si tout va bien, vous avez l’idée et c’est utile!

0
TamusJRoyce

Je suggérerais de regarder lodash et comment ils ont implémenté la fonction trim.

Voir Lodash Trim pour la documentation et la source pour voir le code exact qui effectue le rognage.

Je sais que cela ne fournit pas une réponse exacte à votre question, mais je pense qu’il est bon de définir une référence à une bibliothèque sur une telle question car d’autres pourraient la trouver utile.

0
drew7721