Вы можете использовать пространство имен System.Reflection
с помощью метода Type.GetProperties()
:
PropertyInfo[] propertyInfos;
propertyInfos = typeof(MyClass).GetProperties(BindingFlags.Public|BindingFlags.Static);
Мне нравится этот метод (он выглядит немного чище):
text = text.replace(new RegExp("cat","g"), "dog");
Используйте регулярное выражение:
str.replace(/abc/g, '');
Если строка содержит аналогичный шаблон, подобный abccc
, вы можете использовать это:
str.replace(/abc(\s|$)/g, "")
Использование RegExp
в JavaScript может выполнить эту работу для вас, просто выполните следующее:
var str ="Test abc test test abc test test test abc test test abc";
str = str.replace(/abc/g, '');
Если вы думаете о повторном использовании, создайте функцию, которая сделает это за вас, но это не рекомендуется, так как это только одна функция линии, но если вы сильно ее используете, вы можете написать что-то вроде этого:
String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
return this.replace(new RegExp(string, 'g'), replaced);
};
и просто использовать его в своем коде снова и снова, как показано ниже:
var str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');
Но, как я упоминал ранее, это не будет иметь большого значения в отношении строк, которые должны быть записаны или производительности, только кеширование функции может привести к более быстрой работе на длинных строках, а также хорошей практике кода DRY, если вы хотите повторно использовать.
var string = 'Test abc Test abc Test abc Test abc'
string = string.replace(/abc/g, '')
console.log(string)
Это самая быстрая версия, в которой не использует регулярные выражения .
replaceAll = function(string, omit, place, prevstring) {
if (prevstring && string === prevstring)
return string;
prevstring = string.replace(omit, place);
return replaceAll(prevstring, omit, place, string)
}
It почти в два раза быстрее, чем метод split и join.
Как указано в комментарии здесь, это не будет работать, если ваша переменная omit
содержит place
, как в: replaceAll("string", "s", "ss")
, потому что он всегда сможет заменить другое вхождение слова.
Существует еще один jsperf с вариантами на моей рекурсивной замене, которые идут еще быстрее ( http://jsperf.com/replace-all- vs-split-join / 12 )!
if(place.replace(omit) === omit) {
Нет совпадения, поэтому безопасно использовать цикл замещения } else {
Сопоставьте так, чтобы использовать другой метод, например split и join }
– Cole Lawrence
10 July 2014 в 13:41
str = str.replace(/abc/g, '');
Или попробуйте функцию replaceAll отсюда:
Какие полезные методы JavaScript расширяют встроенные объекты?
str = str.replaceAll('abc', ''); OR
var search = 'abc';
str = str.replaceAll(search, '');
EDIT: Разъяснение о замене доступности All
Метод replaceAll добавлен к прототипу String. Это означает, что он будет доступен для всех строковых объектов / литералов.
Например,
var output = "test this".replaceAll('this', 'that'); //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'
str = str.replace(new RegExp("abc", 'g'), "");
работал лучше для меня, чем приведенные выше ответы. поэтому new RegExp("abc", 'g')
создает RegExp, что соответствует всему присутствию (флаг 'g'
) текста ("abc"
). Вторая часть - это то, что заменяется на, в вашем случае пустую строку (""
). str
- это строка, и мы должны ее переопределить, так как replace(...)
просто возвращает результат, но не переопределяет. В некоторых случаях вы можете использовать это.
Хотя люди упомянули использование регулярных выражений, но есть лучший подход, если вы хотите заменить текст независимо от случая текста. Как прописные или строчные буквы. Используйте синтаксис ниже
//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');
//Output will be all the occurrences removed irrespective of casing.
Здесь вы можете найти подробный пример здесь .
// зацикливать его до появления числа в 0. ИЛИ просто скопировать / вставить
function replaceAll(find, replace, str)
{
while( str.indexOf(find) > -1)
{
str = str.replace(find, replace);
}
return str;
}
.indexOf
в переменной и используйте эту переменную в качестве второго параметра .indexOf
(минус длина ключевого слова, плюс длина строки замены).
– Rob W
29 October 2013 в 13:33
Вот функция прототипа строки, основанная на принятом ответе:
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find, 'g'), replace);
};
EDIT
Если ваш find
будет содержать специальные символы, вам необходимо их избежать:
String.prototype.replaceAll = function (find, replace) {
var str = this;
return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};
Fiddle: http://jsfiddle.net/cdbzL/
find
содержит символы типа .
или $
, которые имеют специальные значения в регулярном выражении?
– callum
7 October 2013 в 12:30
var str = this
создает вторую ссылку на неизменяемую строку, к которой применяется метод replace
, который, в свою очередь, возвращает новая неизменяемая строка i>. эти прототипы возвращают новую неизменяемую строку, если нет, вы могли бы записать someStrVar.replaceAll('o', '0');
и someStrVar
. Вместо этого вам нужно написать someStrVar = someStrVar.replaceAll('o', '0');
& lt; - reassign, чтобы установить var для хранения новой неизменяемой строки i>. это не так. Попробуйте в консоли: x = 'foobar'; x.replaceAll('o', '0'); x;
– Elias Van Ootegem
15 June 2016 в 16:26
Примечание: не используйте это в реальном коде.
. В качестве альтернативы регулярным выражениям для простой литеральной строки вы можете использовать
str = "Test abc test test abc test...".split("abc").join("");
. Общий шаблон
str.split(search).join(replacement)
В некоторых случаях это было быстрее, чем при использовании replaceAll
и регулярного выражения, но в современных браузерах это, похоже, не так. Таким образом, это действительно должно быть использовано только как быстрый хак, чтобы избежать необходимости избегать регулярного выражения, а не реального кода.
String.prototype.replaceAll = function(f,r){return this.split(f).join(r);}
. Использование: "My string".replaceAll('st', '');
производит "My ring & quot;
– MacroMan
26 September 2014 в 12:50
str = str.replace(/abc/g, '');
В ответ на комментарий:
var find = 'abc';
var re = new RegExp(find, 'g');
str = str.replace(re, '');
В ответ на комментарий Click Upvote вы можете упростить его еще больше:
function replaceAll(str, find, replace) {
return str.replace(new RegExp(find, 'g'), replace);
}
Примечание. Регулярные выражения содержат специальные (мета) символы и, как таковые, опасно слепо передавать аргумент в функции find
выше, не предварительно обработав его, чтобы избежать этих символов. Это описано в Справочнике JavaScript Mozilla Developer Network по регулярным выражениям , где они представляют следующую функцию полезности:
function escapeRegExp(str) {
return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}
Итак, в чтобы сделать функцию replaceAll()
выше безопасной, ее можно было бы изменить следующим образом, если вы также включили escapeRegExp
:
function replaceAll(str, find, replace) {
return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
function replaceAll(find, replace,str) { var re = new RegExp(find, 'g'); str = str.replace(re, replace); return str; }
– Click Upvote
17 July 2009 в 22:11
replaceAll
заключается в том, что она не будет работать, если find
содержит метасимволы.
– Martin Ender
27 August 2013 в 01:39
Если то, что вы хотите найти, уже находится в строке, и у вас нет регулярного выражения escaper, вы можете использовать join / split:
function replaceMulti(haystack, needle, replacement)
{
return haystack.split(needle).join(replacement);
}
someString = 'the cat looks like a cat';
console.log(replaceMulti(someString, 'cat', 'dog'));
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);
Использование регулярного выражения с флагом g
заменит все:
someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains "the dog looks like a dog"
var sourceText
количество экземпляров (numOfInstances
) с помощью substring
или разделить и подсчитать длину (среди других стратегий) thatWhichYouWantToReplace
, затем сделать for (var i = 0; i < numOfInstances; i++){ sourceText = sourceText.replace('thatWhichYouWantToReplace', '');
} или даже проще просто использовать while (while sourceText.indexOf(thatWhichYouWantToReplace > -1){ sourceText = sourceText.replace(...)
), но я не понимаю, почему вы хотели бы сделать это таким образом, когда использование /g
настолько легкое и, вероятно, более совершенное.
– Zargold
20 March 2016 в 23:20
Если вы пытаетесь убедиться, что строка, которую вы ищете, не будет существовать даже после замены, вам нужно использовать цикл.
Например:
var str = 'test aabcbc';
str = str.replace(/abc/g, '');
Когда вы закончите, вы все равно будете иметь «test abc»!
. Простейшим циклом для этого было бы:
var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
str.replace(/abc/g, '');
}
Но это выполняет замену дважды для каждого цикла. Возможно (рискуя проголосовать), которые могут быть объединены для немного более эффективной, но менее читаемой формы:
var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!
Это может быть особенно полезно при поиске повторяющихся строк. Например, если у нас есть «a ,,, b», и мы хотим удалить все повторяющиеся запятые. [В этом случае можно было бы сделать .replace (/, + / g, ','), но в какой-то момент регулярное выражение становится сложным и достаточно медленным, чтобы зацикливаться.]
Следующая функция работает для меня:
String.prototype.replaceAllOccurence = function(str1, str2, ignore)
{
return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;
теперь вызывает следующие функции:
"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");
Просто скопируйте и вставьте этот код в консоль вашего браузера в TEST.
Соответствие глобальному регулярному выражению:
anotherString = someString.replace(/cat/g, 'dog');
Я использую p для сохранения результата из предыдущей замены рекурсии:
function replaceAll(s, m, r, p) {
return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}
Он заменит все вхождения в строке s до тех пор, пока это не будет возможно:
replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'
Чтобы избежать бесконечного цикла, я проверяю, содержит ли замена r совпадение m:
replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'
function replaceAll(str, find, replace) {
var i = str.indexOf(find);
if (i > -1){
str = str.replace(find, replace);
i = i + replace.length;
var st2 = str.substring(i);
if(st2.indexOf(find) > -1){
str = str.substring(0,i) + replaceAll(st2, find, replace);
}
}
return str;
}
Вы можете просто использовать ниже метод
/**
* Replace all the occerencess of $find by $replace in $originalString
* @param {originalString} input - Raw string.
* @param {find} input - Target key word or regex that need to be replaced.
* @param {replace} input - Replacement key word
* @return {String} Output string
*/
function replaceAll(originalString, find, replace) {
return originalString.replace(new RegExp(find, 'g'), replace);
};
Просто добавьте /g
document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');
в
// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');
/g
означает глобальный
Вы можете попробовать объединить эти два мощных метода.
"test abc test test abc".split("abc").join("")
Надеюсь, что это поможет!
Моя реализация, очень понятная
function replaceAll(string, token, newtoken) {
if(token!=newtoken)
while(string.indexOf(token) > -1) {
string = string.replace(token, newtoken);
}
return string;
}
replaceAll("123434", "1234", "12")
должен возвращать "1234"
, но вместо этого возвращает "12"
.
– Bryan
16 April 2013 в 14:58
while (str.indexOf('abc') !== -1)
{
str = str.replace('abc', '');
}
Обновление:
Немного поздно для обновления, но поскольку я просто наткнулся на этот вопрос и заметил, что мой предыдущий ответ не тот, которым я доволен. Поскольку вопрос заключался в замене одного слова, невероятно, что никто не думал об использовании границ слов (\b
)
'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"
Это простое регулярное выражение, которое позволяет избежать замены частей слов в большинстве случаев. Однако тире -
по-прежнему считается границей слова. Таким образом, условные выражения могут использоваться в этом случае, чтобы избежать замены строк, таких как cool-cat
:
'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"
в основном, этот вопрос такой же, как и здесь: Javascript replace & quot; '& quot; с " '' & quot;
@Mike, проверьте ответ, который я дал там ... regexp - это не единственный способ заменить несколько вхождений подстроки, далеко от нее. Подумайте об гибкости, подумайте о раздельности!
var newText = "the cat looks like a cat".split('cat').join('dog');
В качестве альтернативы, чтобы предотвратить замену частей слова, которые также будут приняты утвердительный ответ! Вы можете обойти эту проблему, используя регулярные выражения, которые, я признаю, несколько более сложны и, как результат, еще медленнее:
var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
Выход такой же, как и принятый ответ , однако, используя выражение / cat / g в этой строке:
var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ??
На самом деле, это, вероятно, не то, что вы хотите. Что же тогда? IMHO, регулярное выражение, которое заменяет «cat» условно. (т. е. не является частью слова), например:
var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return "the dog looks like a dog, not a caterpillar or coolcat"
Предполагаю, что это соответствует вашим потребностям. Конечно, это не полная защита, но этого должно быть достаточно, чтобы вы начали. Я бы порекомендовал прочитать еще кое-что на этих страницах. Это будет полезно при совершенствовании этого выражения для удовлетворения ваших конкретных потребностей.
http://www.javascriptkit.com/jsref/regexp.shtml
http://www.regular-expressions.info
Окончательное дополнение:
Учитывая, что этот вопрос по-прежнему получает много просмотров, Я думал, что могу добавить пример .replace
, используемый с функцией обратного вызова. В этом случае он значительно упрощает выражение и обеспечивает еще большую гибкость, например, замену правильной капитализацией или замену как cat
, так и cats
за один раз:
'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
.replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
{
//check 1st, capitalize if required
var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
if (char1 === ' ' && char2 === 's')
{//replace plurals, too
cat = replacement + 's';
}
else
{//do not replace if dashes are matched
cat = char1 === '-' || char2 === '-' ? cat : replacement;
}
return char1 + cat + char2;//return replacement string
});
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar
Замена одинарных кавычек:
function JavaScriptEncode(text){
text = text.replace(/'/g,''')
// More encode here if required
return text;
}