Découper un caractère spécifique d'une chaîne

Quel est l' équivalent JavaScript de cette C#méthode:

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

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

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

Une solution générale:

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

chars = ".|]\\";
for (c of chars) {
  s = c + "foo" + c + c + "oo" + c + c + c;
  console.log(s, "->", trim(s, c));
}

Si j'ai bien compris, vous souhaitez 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, "|") + "'" );

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 cela dans une fonction, vous pouvez effectuer les opérations suivantes:

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

pour garder cette question à jour:

voici une approche que je choisirais plutôt que la fonction regex en utilisant 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);
}

Version améliorée après le commentaire de @fabian (peut gérer les chaînes contenant le même caractère uniquement)

function trimByChar(string, character) {
  const arr = Array.from(string);
  const first = arr.indexOf(character);
  const last = arr.reverse().indexOf(character);
  return string.substring(first + 1, string.length - last - 1);
}

Une version sans regex qui est agréable à l'œil:

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.

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 découper 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'

MODIFIER: Pour le plaisir, découpez des mots (plutôt que des caractères individuels)

// Helper function to detect if a string contains another string
//     at a specific position. 
// Equivalent to using `str.indexOf(substr, pos) === pos` but *should* be more efficient on longer strings as it can exit early (needs benchmarks to back this up).
function hasSubstringAt(str, substr, pos) {
    var idx = 0, len = substr.length;

    for (var max = str.length; idx < len; ++idx) {
        if ((pos + idx) >= max || str[pos + idx] != substr[idx])
            break;
    }

    return idx === len;
}

function trimWord(str, word) {
    var start = 0,
        end = str.length,
        len = word.length;

    while (start < end && hasSubstringAt(str, word, start))
        start += word.length;

    while (end > start && hasSubstringAt(str, word, end - len))
        end -= word.length

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

// Usage:
trimWord('blahrealmessageblah', 'blah');

Cela peut couper plusieurs caractères à 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

Si vous définissez ces fonctions dans votre programme, vos chaînes auront une version améliorée de trimqui peut couper tous les caractères donnés:

String.prototype.trimLeft = function(charlist) {
	if (charlist === undefined)
	charlist = "\s";

	return this.replace(new RegExp("^[" + charlist + "]+"), "");
};

String.prototype.trim = function(charlist) {
	return this.trimLeft(charlist).trimRight(charlist);
};

String.prototype.trimRight = function(charlist) {
	if (charlist === undefined)
	charlist = "\s";

	return this.replace(new RegExp("[" + charlist + "]+$"), "");
};

var withChars = "/-center-/"
var withoutChars = withChars.trim("/-")
document.write(withoutChars)

La source

https://www.sitepoint.com/trimming-strings-in-javascript/

À ma connaissance, jQuery n'a pas de fonction intégrée à la méthode que vous demandez. Cependant, avec javascript, vous pouvez simplement utiliser replace pour modifier le contenu de votre chaîne:

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

Cela remplacera toutes les occurrences de | avec rien.

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

Je suggérerais de regarder lodash et comment ils ont mis en œuvre la trimfonction.

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.

La meilleure façon de résoudre cette tâche est (similaire avec la trimfonction PHP ):

function trim( str, charlist ) {
  if ( typeof charlist == 'undefined' ) {
    charlist = '\\s';
  }
  
  var pattern = '^[' + charlist + ']*(.*?)[' + charlist + ']*$';
  
  return str.replace( new RegExp( pattern ) , '$1' )
}

document.getElementById( 'run' ).onclick = function() {
  document.getElementById( 'result' ).value = 
  trim( document.getElementById( 'input' ).value,
  document.getElementById( 'charlist' ).value);
}

<div>
  <label for="input">Text to trim:</label><br>
  <input id="input" type="text" placeholder="Text to trim" value="dfstextfsd"><br>
  <label for="charlist">Charlist:</label><br>
  <input id="charlist" type="text" placeholder="Charlist" value="dfs"><br>
  <label for="result">Result:</label><br>
  <input id="result" type="text" placeholder="Result" disabled><br>
  <button type="button" id="run">Trim it!</button>
</div>

PS: pourquoi j'ai posté ma réponse, alors que la plupart des gens l'ont déjà fait avant? Parce que j'ai trouvé "la meilleure" erreur dans toutes leurs réponses: tous ont utilisé la méta '+' au lieu de '*', car ils trimdoivent supprimer les caractères SI ILS SONT EN DÉBUT ET / OU FIN, mais il renvoie la chaîne d'origine dans le cas contraire .

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
}

J'aime la solution de @ Pho3niX83 ...

Étendons-le avec "mot" 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);
};

function trim(text, val) {
    return text.replace(new RegExp('^'+val+'+|'+val+'+$','g'), '');
}

"|Howdy".replace(new RegExp("^\\|"),"");

(notez le double échappement. \\nécessaire, pour avoir une barre oblique unique dans la chaîne , qui conduit alors à l'échappement de |dans regExp ).

Seuls quelques caractères ont besoin de regExp-Escaping. , parmi eux l'opérateur de tuyauterie.

essayer:

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

String.prototype.TrimStart = function (n) {
    if (this.charAt(0) == n)
        return this.substr(1);
};

String.prototype.TrimEnd = function (n) {
    if (this.slice(-1) == n)
        return this.slice(0, -1);
};

Essayez cette méthode:

var a = "anan güzel mi?";
if (a.endsWith("?"))   a = a.slice(0, -1);  
document.body.innerHTML = a;