Как заменить несколько пробелов одним пробелом
Вы отправили действие fetchmystuff. Внутри вашего компонента, вы захотите либо.
1. запросить в магазине состояние value
computed: {
value() {
return this.$store.state.value
}
}
2. вызвать метод получения, который получает состояние value из вычисляемого свойства
в компоненте
computed: { value() { return this.$store.getters.value } }в хранилище getters.js
getters: { // ... value: (state, getters) => { return getters.value } }Диспетчеру / действию не требуется доступ к компоненту
(поскольку состояние устанавливается только в хранилище с помощью мутаций / фиксаций, а состояние передается другим компонентам через геттеры).Это позволяет разделить проблемы между магазином и составными частями вашего приложения.
10 ответов
string cleanedString = System.Text.RegularExpressions.Regex.Replace(dirtyString,@"\s+"," ");
Заменяющие группы обеспечивают замену разрешения подхода impler приблизительно пробел символы с тот же единственный:
public static void WhiteSpaceReduce()
{
string t1 = "a b c d";
string t2 = "a b\n\nc\nd";
Regex whiteReduce = new Regex(@"(?<firstWS>\s)(?<repeatedWS>\k<firstWS>+)");
Console.WriteLine("{0}", t1);
//Console.WriteLine("{0}", whiteReduce.Replace(t1, x => x.Value.Substring(0, 1)));
Console.WriteLine("{0}", whiteReduce.Replace(t1, @"${firstWS}"));
Console.WriteLine("\nNext example ---------");
Console.WriteLine("{0}", t2);
Console.WriteLine("{0}", whiteReduce.Replace(t2, @"${firstWS}"));
Console.WriteLine();
}
заметьте, что второй пример сохраняет единственным \n, в то время как принятый ответ заменил бы конец строки с пространством.
, Если необходимо заменить какой-либо комбинация пробельных символов с первым, просто удалите обратную ссылку \k из шаблона.
Нет встроенного способа сделать это. Вы можете попробовать следующее:
private static readonly char[] whitespace = new char[] { ' ', '\n', '\t', '\r', '\f', '\v' };
public static string Normalize(string source)
{
return String.Join(" ", source.Split(whitespace, StringSplitOptions.RemoveEmptyEntries));
}
Это удалит начальные и конечные пробелы, а также свернет все внутренние пробелы до одного символа пробела. Если вы действительно хотите свернуть только пробелы, тогда решения, использующие регулярное выражение, лучше; в противном случае это решение лучше. (См. Анализ , сделанный Джоном Скитом.)
Как уже отмечалось, это легко сделать с помощью регулярного выражения. Я просто добавлю, что вы можете добавить к нему .trim (), чтобы избавиться от начальных / конечных пробелов.
Regex regex = new Regex(@"\W+");
string outputString = regex.Replace(inputString, " ");
Обычный экспрессоин был бы самым простым способом. Если вы напишете регулярное выражение правильно, вам не понадобится несколько вызовов.
Измените его на это:
string s = System.Text.RegularExpressions.Regex.Replace(s, @"\s{2,}", " ");
Этот вопрос не так прост, как его задают другие плакаты (и как я изначально предполагал) - потому что вопрос не совсем точен, как должен быть .
Есть разница между «пробелом» и «пробелом». Если вы только имеете в виду пробелы, тогда вам следует использовать регулярное выражение "{2,}" . Другое дело, если вы имеете в виду любой пробел. Следует ли все пробелы преобразовать в пробелы? Что должно произойти с пробелами в начале и в конце?
Для теста ниже я предположил, что вас интересуют только пробелы, и вы не хотите ничего делать с отдельными пробелами, даже в начале и в конце.
Обратите внимание, что правильность почти всегда важнее производительности. Тот факт, что решение Split / Join удаляет любые начальные / конечные пробелы (даже отдельные пробелы), неверен в соответствии с вашими указанными требованиями (которые, конечно, могут быть неполными).
В тесте используется MiniBench ].
using System;
using System.Text.RegularExpressions;
using MiniBench;
internal class Program
{
public static void Main(string[] args)
{
int size = int.Parse(args[0]);
int gapBetweenExtraSpaces = int.Parse(args[1]);
char[] chars = new char[size];
for (int i=0; i < size/2; i += 2)
{
// Make sure there actually *is* something to do
chars[i*2] = (i % gapBetweenExtraSpaces == 1) ? ' ' : 'x';
chars[i*2 + 1] = ' ';
}
// Just to make sure we don't have a \0 at the end
// for odd sizes
chars[chars.Length-1] = 'y';
string bigString = new string(chars);
// Assume that one form works :)
string normalized = NormalizeWithSplitAndJoin(bigString);
var suite = new TestSuite<string, string>("Normalize")
.Plus(NormalizeWithSplitAndJoin)
.Plus(NormalizeWithRegex)
.RunTests(bigString, normalized);
suite.Display(ResultColumns.All, suite.FindBest());
}
private static readonly Regex MultipleSpaces =
new Regex(@" {2,}", RegexOptions.Compiled);
static string NormalizeWithRegex(string input)
{
return MultipleSpaces.Replace(input, " ");
}
// Guessing as the post doesn't specify what to use
private static readonly char[] Whitespace =
new char[] { ' ' };
static string NormalizeWithSplitAndJoin(string input)
{
string[] split = input.Split
(Whitespace, StringSplitOptions.RemoveEmptyEntries);
return string.Join(" ", split);
}
}
Несколько запусков тестов:
c:\Users\Jon\Test>test 1000 50
============ Normalize ============
NormalizeWithSplitAndJoin 1159091 0:30.258 22.93
NormalizeWithRegex 26378882 0:30.025 1.00
c:\Users\Jon\Test>test 1000 5
============ Normalize ============
NormalizeWithSplitAndJoin 947540 0:30.013 1.07
NormalizeWithRegex 1003862 0:29.610 1.00
c:\Users\Jon\Test>test 1000 1001
============ Normalize ============
NormalizeWithSplitAndJoin 1156299 0:29.898 21.99
NormalizeWithRegex 23243802 0:27.335 1.00
Здесь первое число - это количество итераций, второе - затраченное время, а третье - масштабированный балл, где 1.0 является лучшим.
Это показывает, что в по крайней мере, в некоторых случаях (включая этот) регулярное выражение может превзойти решение Split / Join, иногда с очень значительным отрывом.
Однако, если вы измените требование «все пробелы», тогда Разделение / объединение делает выигрышным. Как это часто бывает, дьявол кроется в деталях ...
конечно).Тест использует MiniBench .
using System;
using System.Text.RegularExpressions;
using MiniBench;
internal class Program
{
public static void Main(string[] args)
{
int size = int.Parse(args[0]);
int gapBetweenExtraSpaces = int.Parse(args[1]);
char[] chars = new char[size];
for (int i=0; i < size/2; i += 2)
{
// Make sure there actually *is* something to do
chars[i*2] = (i % gapBetweenExtraSpaces == 1) ? ' ' : 'x';
chars[i*2 + 1] = ' ';
}
// Just to make sure we don't have a \0 at the end
// for odd sizes
chars[chars.Length-1] = 'y';
string bigString = new string(chars);
// Assume that one form works :)
string normalized = NormalizeWithSplitAndJoin(bigString);
var suite = new TestSuite<string, string>("Normalize")
.Plus(NormalizeWithSplitAndJoin)
.Plus(NormalizeWithRegex)
.RunTests(bigString, normalized);
suite.Display(ResultColumns.All, suite.FindBest());
}
private static readonly Regex MultipleSpaces =
new Regex(@" {2,}", RegexOptions.Compiled);
static string NormalizeWithRegex(string input)
{
return MultipleSpaces.Replace(input, " ");
}
// Guessing as the post doesn't specify what to use
private static readonly char[] Whitespace =
new char[] { ' ' };
static string NormalizeWithSplitAndJoin(string input)
{
string[] split = input.Split
(Whitespace, StringSplitOptions.RemoveEmptyEntries);
return string.Join(" ", split);
}
}
Несколько тестовых прогонов:
c:\Users\Jon\Test>test 1000 50
============ Normalize ============
NormalizeWithSplitAndJoin 1159091 0:30.258 22.93
NormalizeWithRegex 26378882 0:30.025 1.00
c:\Users\Jon\Test>test 1000 5
============ Normalize ============
NormalizeWithSplitAndJoin 947540 0:30.013 1.07
NormalizeWithRegex 1003862 0:29.610 1.00
c:\Users\Jon\Test>test 1000 1001
============ Normalize ============
NormalizeWithSplitAndJoin 1156299 0:29.898 21.99
NormalizeWithRegex 23243802 0:27.335 1.00
Здесь первое число - это количество итераций, второе - время, а третье - оценка по шкале, где 1.0 является лучшим.
Это показывает, что по крайней мере в некоторых случаях (включая этот) регулярное выражение может превзойти решение Split / Join, иногда с очень значительным отрывом.
Однако, если вы измените требование «все пробелы», то разделение / объединение действительно окажется выигрышным. Как это часто бывает, дьявол кроется в деталях ...
конечно).Тест использует MiniBench .
using System;
using System.Text.RegularExpressions;
using MiniBench;
internal class Program
{
public static void Main(string[] args)
{
int size = int.Parse(args[0]);
int gapBetweenExtraSpaces = int.Parse(args[1]);
char[] chars = new char[size];
for (int i=0; i < size/2; i += 2)
{
// Make sure there actually *is* something to do
chars[i*2] = (i % gapBetweenExtraSpaces == 1) ? ' ' : 'x';
chars[i*2 + 1] = ' ';
}
// Just to make sure we don't have a \0 at the end
// for odd sizes
chars[chars.Length-1] = 'y';
string bigString = new string(chars);
// Assume that one form works :)
string normalized = NormalizeWithSplitAndJoin(bigString);
var suite = new TestSuite<string, string>("Normalize")
.Plus(NormalizeWithSplitAndJoin)
.Plus(NormalizeWithRegex)
.RunTests(bigString, normalized);
suite.Display(ResultColumns.All, suite.FindBest());
}
private static readonly Regex MultipleSpaces =
new Regex(@" {2,}", RegexOptions.Compiled);
static string NormalizeWithRegex(string input)
{
return MultipleSpaces.Replace(input, " ");
}
// Guessing as the post doesn't specify what to use
private static readonly char[] Whitespace =
new char[] { ' ' };
static string NormalizeWithSplitAndJoin(string input)
{
string[] split = input.Split
(Whitespace, StringSplitOptions.RemoveEmptyEntries);
return string.Join(" ", split);
}
}
Несколько тестовых прогонов:
c:\Users\Jon\Test>test 1000 50
============ Normalize ============
NormalizeWithSplitAndJoin 1159091 0:30.258 22.93
NormalizeWithRegex 26378882 0:30.025 1.00
c:\Users\Jon\Test>test 1000 5
============ Normalize ============
NormalizeWithSplitAndJoin 947540 0:30.013 1.07
NormalizeWithRegex 1003862 0:29.610 1.00
c:\Users\Jon\Test>test 1000 1001
============ Normalize ============
NormalizeWithSplitAndJoin 1156299 0:29.898 21.99
NormalizeWithRegex 23243802 0:27.335 1.00
Здесь первое число - это количество итераций, второе - время, а третье - оценка по шкале, где 1.0 является лучшим.
Это показывает, что по крайней мере в некоторых случаях (включая этот) регулярное выражение может превзойти решение Split / Join, иногда с очень значительным отрывом.
Однако, если вы измените требование «все пробелы», то разделение / объединение действительно окажется выигрышным. Как это часто бывает, дьявол кроется в деталях ...
Это показывает, что по крайней мере в некоторых случаях (включая этот) регулярное выражение может превзойти решение Split / Join, иногда с очень значительным отрывом.
Однако, если вы перейдете на Требование "все пробелы", тогда Split / Join действительно выигрывает. Как это часто бывает, дьявол кроется в деталях ...
Это показывает, что по крайней мере в некоторых случаях (включая этот) регулярное выражение может превзойти решение Split / Join, иногда с очень значительным отрывом.
Однако, если вы перейдете на требование "все пробелы", тогда разделение / объединение действительно , похоже, выигрывает. Как это часто бывает, дьявол кроется в деталях ...
Хотя существующие ответы хороши, я хотел бы указать на один подход, который не работает:
public static string DontUseThisToCollapseSpaces(string text)
{
while (text.IndexOf(" ") != -1)
{
text = text.Replace(" ", " ");
}
return text;
}
Это может повторяться бесконечно. Кто-нибудь хочет угадать, почему? (Я наткнулся на это только тогда, когда несколько лет назад его задали как вопрос группы новостей ... кто-то действительно столкнулся с этим как с проблемой.)
Наименьшее решение:
var regExp = / \ s + / g, newString = oldString.replace (regExp, '');
Я делюсь тем, что я использую, потому что, похоже, я придумал что-то другое. Я использовал это некоторое время, и это достаточно быстро для меня. Я не уверен, как он складывается против других. Я использую его в разделите файловый писатель и запустить большие источники данных по одному в течение него.
public static string NormalizeWhiteSpace(string S)
{
string s = S.Trim();
bool iswhite = false;
int iwhite;
int sLength = s.Length;
StringBuilder sb = new StringBuilder(sLength);
foreach(char c in s.ToCharArray())
{
if(Char.IsWhiteSpace(c))
{
if (iswhite)
{
//Continuing whitespace ignore it.
continue;
}
else
{
//New WhiteSpace
//Replace whitespace with a single space.
sb.Append(" ");
//Set iswhite to True and any following whitespace will be ignored
iswhite = true;
}
}
else
{
sb.Append(c.ToString());
//reset iswhitespace to false
iswhite = false;
}
}
return sb.ToString();
}