Страницы: Пред. 1 2 3 След.
RSS
bedvit. Как использовать решения автора, COM и XLL. Отличие и подключение
 
bedvit, сильно дополнил пост сверху)) тест сделаю, а поиск без учёта регистра мне не нужен (особо)  ;)
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Цитата
bedvit написал:
ПРОБЛЕМАБиблиотека очень часто крашится… В основном, когда подключена одновременно и к надстройке (сторонней) и к активной книге
Моя? Нужно понять какая СОМ или XLL. А так же собрать статистику в каких случаях. У себя такого не замечал. Возможно оставить вариант только с настройкой, зачем отдельно подключать к активной книге?
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, не - проблема не ваша. У меня же только))) я пока потестирую только в своей надстройке…
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
bedvit, простейший стенд готов. В первом акте меняем "aa" и "zz" на одиночные символы.

Результаты на 1 млн цикла одной и той же строки:
1. Регулярки:     5,8 сек (кто бы сомневался)
2. Replace4x:     22,5 сек (в данном случае 3 проходов оказалось мало)
3. ReplaceInStr: 28,5 сек (гарантированная замена с проверкой)
Тестовый стенд
если обгонять регулярки запарно, то может и не стоит игра свеч…
Изменено: Jack Famous - 08.08.2019 11:17:17
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Моя реализация InStr, тест на 1 млн. символов -10 тыс. итераций.
Пока паритет со стандартной.
Time InStr 5,367188 сек
1000074
Time bVBA.InStr 5,367188 сек
1000074

Коллеги, как можно улучшить код? (BSTR - это массив символов Юникода)
Массив начинается с 0.
задача как можно меньше запускать второй цикл.
Код
STDMETHODIMP CVBA::InStr(BSTR StringIn, BSTR StringFind, LONG Start, LONG* Position)
{
   LONG iSize = SysStringLen(StringIn);
   LONG fSize = SysStringLen(StringFind);
   if (Start < 1 || Start > iSize) return E_INVALIDARG;
   if (fSize == 0) return E_INVALIDARG;
   LONG i = --Start;
   LONG j;

   for (i; i < iSize; ++i)
   {
      if (StringIn[i] == StringFind[0]) 
      {
         for (j = 1; j < fSize; ++j)
         {
            if (StringIn[i+j] != StringFind[j]) { break; }
         }
         if (j == fSize)
         {
            *Position = i+1;
            return S_OK;
         }
      }
   }
   *Position = 0;
   return S_OK;
}
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, по коду не подскажу, а вот по тесту: может тестить на строке до 500 символов? Это реальная максимальная длина очень длинных строк (за редким исключением). А вообще обычно не более 150 символов… Зачем тестить на том, чего никогда не будет в жизни  :)

UPD:
отсюда
Код
int CGlobal::InStr(string str, string what, int pos)
{
    // int InStr(start-1, str, what)
    if (pos >= 0)
    {
        if (pos == 0)
        {
            return str.find_first_of(what) + 1; 
        }else{
            return str.find_first_of(what, pos) + 1;
        };
    }else{
        return -1;
    };
}
отсюда
Код
// string::find
#include <iostream>       // std::cout
#include <string>         // std::string

int main ()
{
  std::string str ("There are two needles in this haystack with needles.");
  std::string str2 ("needle");

  // different member versions of find in the same order as above:
  std::size_t found = str.find(str2);
  if (found!=std::string::npos)
    std::cout << "first 'needle' found at: " << found << '\n';

  found=str.find("needles are small",found+1,6);
  if (found!=std::string::npos)
    std::cout << "second 'needle' found at: " << found << '\n';

  found=str.find("haystack");
  if (found!=std::string::npos)
    std::cout << "'haystack' also found at: " << found << '\n';

  found=str.find('.');
  if (found!=std::string::npos)
    std::cout << "Period found at: " << found << '\n';

  // let's replace the first needle:
  str.replace(str.find(str2),str2.length(),"preposition");
  std::cout << str << '\n';

  return 0;
}
Изменено: Jack Famous - 08.08.2019 17:25:01
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Jack Famous, потому как слишком быстрые функции.
Удалось обогнать в некоторых тестах стандартную InStr на строках в 1 млн.символов в 5,5 раз, на строках в 500 символов в 4,5 раза. В случаях когда в исходной строке часто встречается символ, с которого начинается строка, которую ищем. Двольно частая ситуация. Видимо не до конца оптимизировали. Тест прилагаю.
Загрузил тестовую библу v1.0.0.7.DEBUG.rar

Тайминг 500 символов, 1 млн. итераций:
Time InStr 2,98 сек
позиция 574
Time bVBA.InStr 0,65  сек
позиция 574

Пришлось использовать всеми любимую goto.
Код в dll:
Скрытый текст
Изменено: bedvit - 09.08.2019 09:38:05
«Бритва Оккама» или «Принцип Калашникова»?
 
Цитата
Jack Famous написал:
str.find_first_of
Цитата
Jack Famous написал:
str.find(str2);
Jack Famous, ваши примеры используют встроенные инструменты поиска из стандартной библиотеки std::string. Думаю они будут медленнее, в силу копирования данных в памяти для возможности использовать стандартную библиотеку (конструкторы, деструкторы строки). Я читаю сразу из памяти, без копирования, по указателю переданной строки (BSTR).
Но за примеры спасибо)
Изменено: bedvit - 08.08.2019 17:48:38
«Бритва Оккама» или «Принцип Калашникова»?
 
Цитата
bedvit: Удалось обогнать
приветствую, Виталий!
Ща погоняю на своих данных)) Есть ли всё-таки Replace в планах?  :)
Цитата
bedvit: Пришлось использовать всеми любимую goto
что лишний раз доказывает полезность разумного её применения  ;) я вообще очень уважаю беготню по меткам, т.к. они очень шустрые и больших циклах могут дать неплохой прирост. Например проверка If Len(x) Then быстрее If Len(x)>0 Then, а GoTo равен или даже чуть выигрывает при гораздо большей универсальности
Цитата
bedvit: за примеры спасибо
чем богаты, как говорится  :D вот если бы вы кусочек кода в VBA написали, то посмотрел бы. Хотя когда там уже разговор идёт о прямой работе с памятью, то тут нужна команда куда серьёзней меня: Андрей VG, sokol92 и Казанский (может ещё кого-то из мэтров, глубоко ныряющих в код, забыл) :idea:
Изменено: Jack Famous - 09.08.2019 09:19:41
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Цитата
Jack Famous написал:
Есть ли всё-таки Replace в планах?
Да, сделаю.
Цитата
Jack Famous написал:
кусочек кода в VBA написали,
там все просто, найти длину, запустить два цикла, выдать результат. Если будет время, переведу.
«Бритва Оккама» или «Принцип Калашникова»?
 
Новая функция "Replace"
Библиотека v1.0.0.7.DEBUG.zip

Тест на строке 200 символов, 100 заменить, 1 млн. итераций:
Replace 12,48 сек
bVBA.Replace 0,67 сек

Итого быстрее в 19 раз на 100 замен.

Тестируйте.
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit,1 млн прогонов,
строка 520 символов
1. Сравнение, InStr " в лоб" поиск подстроки "FIND" в 497 позиции. Классика - ~650 мс. bedvit - 660-670 ms. Минимальное преимущество штатной, можно списать на погрешность
2. Сравнение в качестве замены штатной в составе Sub ReplaceInStr — около 0,5 сек выигрыша bedvit'а

… сравнение прекращено из-за новой функции  :D
Изменено: Jack Famous - 09.08.2019 11:30:22
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
bedvit, уже взялся))) первые вопросы: аргументы у вашей Replace такие же, как у оргинала, но Count что-то не работает -
Код
Sub t()
Static bVBA As BedvitCOM.VBA:   If bVBA Is Nothing Then Set bVBA = New BedvitCOM.VBA
MsgBox bVBA.Replace("анатолий", "а", "ы", , 1)
End Sub
должен выдать "анытолий", а выдаёт всё-равно "ынытолий". Плюс, как мне кажется, при указании Start'а всё-таки не стоит обрезать результат, это указание, как мне кажется, нужно только, чтобы ускорить замену в длинных строках…
Изменено: Jack Famous - 09.08.2019 11:42:28
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Start- не обрезает результат, Count - еще не допилен (не работает), т.е. заменяются все вхождения. Остальное - все рабочее. Все параметры аналогичны обычной функции, за исключением того, что строка не обрезается (сейчас проверю). Проверил - работает как и стандартная - обрезает. Т.е. функционал/итоги абсолютно одинаковы, за исключением скорости. Хотим изменить алгоритм в сравнении со стандартной?
Изменено: bedvit - 09.08.2019 12:14:42
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, я тут пока тесты завершил))) Потрясающе! При увеличении количества заменяемых элементов, ваша Replace улетает (отрывается) просто в космос  :D   :idea: чтоб, вы понимали — регулярки разбиты  :D

Замена 8 двойных символов одинарными аналогами (100 k элементов):
Replace4x: классика - 6,3, bedvit - 2,95 (!!!). Это при условии 4х прогонов без проверки  :excl:
ReplaceInStr: классика - 6,4; bedvit(Replace+Instr) - 3,2;  bedvitReplace + штатная Instr - 3-3,1
ReplaceRegExp: 5,9
+ InStr от bedvit'а немного, но стабильно проигрывает штатному. Особенно это заметно при сравнении в составе других функций… Вполне допускаю, что на длинных строках покажет себя лучше, да и тест был уж очень узкоспециализированный.

Главный вывод: смело берём и используем!  :D
Тестовый стенд
'===========================================================­=========================================
По необязательным аргументам Replace даже не знаю — никогда их не использовал… Думаю, что нужно сделать так, как быстрее (в вашем алгоритме). А при прочих равных вот не могу представить, чтобы мне нужно было обрезать строку с некоторого символа, при условии, что я буду менять что-то после него и вообще непонятно на какой позиции… Штатные Left$, Mid$ и Right$ весьма скоростные, так что "обрезать" я всегда смогу  :)
Изменено: Jack Famous - 09.08.2019 13:41:46
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Цитата
#31. Jack Famous: хоть Replace и не удаляет ничего, если в строке нет нужного, но добавление условия If Instr(1, строка, что_ищем) позволяет стабильно ускорить процесс. Если возьмётесь, то было бы круто вшить что-то подобное внутрь
Цитата
#32. bedvit: думаю в данном случае это не пригодится
забыл сказать, что проверка на InStr перед Replace по-прежнему (я про bVBA.Replace()) стабильно сокращает общее время выполнения (немного). Можно и нужно ли это оптимизировать?…
Изменено: Jack Famous - 09.08.2019 13:36:47
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Цитата
Jack Famous написал:
InStr от bedvit'а немного, но стабильно проигрывает штатному.
в зависимости от строки, есть совсем мизерный проигрыш, до выигрыша в 5 раз. Все зависит от того, встречается ли в строке поиска первый символ строки, которую ищем. Мой алгоритм это эффективно проверяет, стандартный отстает. Хотите давайте тесты проведем. Обычно довольно часто встречается такая ситуация при длинной строке.
Цитата
Jack Famous написал:
проверка на InStr перед Replace по-прежнему (я про bVBA.Replace()) стабильно сокращает общее время выполнения (немного).
можно простой пример?
«Бритва Оккама» или «Принцип Калашникова»?
 
Реализован весь функционал.
Count - работает.
Start - не усекает строку.
Библиотека v1.0.0.7.DEBUG.zip

Тестируйте.

Про оптимизацию жду пример. Возможно из-за усечения строки у вас и тайминги были такие. Вообщем нужно смотреть на примере.
«Бритва Оккама» или «Принцип Калашникова»?
 
Цитата
bedvit: совсем мизерный проигрыш, до выигрыша в 5 раз
тогда вопрос снят. Как я уже писал, у меня крайне узкоспециализированные тесты…
Цитата
bedvit: можно простой пример?
Простой пример

Итоги (у меня):
Массив {1, 2, 3, 4} (2 есть, 2 нет): без проверки - 5,4; с проверкой - 5,2
Массив {1, 3} (всё есть): без проверки - 3,45; с проверкой - 4,1
Массив {2, 4} (ничего нет): без проверки - 3; с проверкой - 2,1
Изменено: Jack Famous - 09.08.2019 16:13:51
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Jack Famous, если заведомо известно, что вхождения есть, включение проверки через InStr - увеличивает время.
Возможно целесообразно использовать InStr, когда с большой долей вероятности можно сказать, что вхождений не должно быть.
Тогда выигрыш будет, за счёт того, что "InStr" быстрее чем "Replace".
Включать эту проверку в bVBA.Replace, значит увеличить время работы функции.
Подразумевается, что используя эту функцию, программист уверен, что вхождения есть.
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, всё так и есть. Учитывая, что InStr отрабатывает лям менее чем за 0,5 сек, я теперь его включаю в 99% случаев  :D
Вы скажете, когда Replace будет допилена или она уже?)
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Jack Famous, уже. см. п48
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, огромное вам спасибо!
Тесты будут уже в понедельник  ;) Хороших вам выходных  :)
Изменено: Jack Famous - 09.08.2019 17:34:02
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Цитата
Jack Famous написал:
bedvit : совсем мизерный проигрыш, до выигрыша в 5 разтогда вопрос снят. Как я уже писал, у меня крайне узкоспециализированные тесты…
в большинстве стандартных случаев действительно проигрывает.  Выигрыш обычно появляется на длинных строках (сотни тысяч и выше символов). Подумаю что можно еще сделать. Спецы писавшие стандартную InStr, намного прокаченнее меня, трудно соревноваться :)

Вот придумал такой генератор случайной строки и нужного случайного числа(строки)
Код
Option Explicit
Sub RUN() 'для раннего связывания
'Подключаем библу "BedvitCOM" в References - version(1.0) для раннего связывания (если библа уже подключена - On Error Resume Next)
'Для раннего связывания сначала включаем в References библу, потом в конце кода отключаем. Для позднего связывания этого не нужно (см.ниже).
'Если BedvitCOM не оключать, могут быть ошибки в этом файле при отсутствии зарегестрированной BedvitCOM - выслали кому-то файл, или открыли из другого ПК и т.д., где не установлеена или не открыта надстройка BedvitXLL (которая автоматом распаковывает и регистрирует библиотеку BedvitCOM в реестре) или не зарегистрированна BedvitCOM вручную
'References хранятся в файле
On Error Resume Next
ThisWorkbook.VBProject.References.AddFromGuid "{77D79CA3-15A0-4310-B8D8-0BCBE3F72D96}", 1, 0 ' подключаем библу "BedvitCOM" в References - version(1.0) для раннего связывания (если библа уже подключена - On Error Resume Next)
Test
ThisWorkbook.VBProject.References.Remove ThisWorkbook.VBProject.References("BedvitCOM") 'оключаем библу в References
End Sub

Sub Test()
Dim s As String, x, t, s2, s3, s4
Dim bVBA As BedvitCOM.VBA: Set bVBA = New BedvitCOM.VBA 'раннее связывание
'Dim bVBA As Object: Set bVBA = CreateObject("BedvitCOM.VBA") 'позднее связывание

Randomize
For x = 0 To 10000
s = s + Format(Rnd() * 10000000000#, "0000000000")
Next
s2 = Format(Rnd() * 100000, "00000")
Debug.Print "find-"; s2

t = Timer
For x = 1 To 10000
s4 = InStr(s, s2)
Next
Debug.Print "InStr "; Timer - t; " сек, позиция-"; s4

t = Timer
For x = 1 To 10000
s4 = bVBA.InStr(s, s2)
Next
Debug.Print "bVBA.InStr "; Timer - t; " сек, позиция-"; s4

End Sub
Изменено: bedvit - 09.08.2019 20:35:35
«Бритва Оккама» или «Принцип Калашникова»?
 
Возможно вызов функции из моей СОМ стоит дороже вызова стандартной. Тогда частые вызовы функций играют на конкурента. Когда вызовов мало, но данных много, ситуация меняется. Надо над этим подумать.
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, доброго дня! Благодарю за тесты и генератор  :idea:
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Сегодня конкуренты нервно курят в сторонке. bVBA.InStr в разы быстрее стандартной InStr на любой длинны строках.
Библиотека BedvitDLL(1.0.0.8).zip
Replace оптимизировал в плане стабильности на разного размера строк. Обгоняет стандартную в разы/на порядок (в некоторых случаях).
Новые функции (в новой библиотеке):  bVBA.InStr и bVBA.Replace ни в одном тесте не проиграли стандартным.
Обязательно к тестированию :)
Ключ к успеху:
быстрое копирование памяти
Максимально быстрое сравнение двух блоков памяти

Тестовый фал выкладываю.
Код:
Код
Option Explicit
Sub RUN() 'для раннего связывания
'Подключаем библу "BedvitCOM" в References - version(1.0) для раннего связывания (если библа уже подключена - On Error Resume Next)
'Для раннего связывания сначала включаем в References библу, потом в конце кода отключаем. Для позднего связывания этого не нужно (см.ниже).
'Если BedvitCOM не оключать, могут быть ошибки в этом файле при отсутствии зарегестрированной BedvitCOM - выслали кому-то файл, или открыли из другого ПК и т.д., где не установлеена или не открыта надстройка BedvitXLL (которая автоматом распаковывает и регистрирует библиотеку BedvitCOM в реестре) или не зарегистрированна BedvitCOM вручную
'References хранятся в файле
On Error Resume Next
ThisWorkbook.VBProject.References.AddFromGuid "{77D79CA3-15A0-4310-B8D8-0BCBE3F72D96}", 1, 0 ' подключаем библу "BedvitCOM" в References - version(1.0) для раннего связывания (если библа уже подключена - On Error Resume Next)
Test
ThisWorkbook.VBProject.References.Remove ThisWorkbook.VBProject.References("BedvitCOM") 'оключаем библу в References
End Sub
 
Sub Test()
Dim s As String, x, t, s2, s3, s4
Dim bVBA As BedvitCOM.VBA: Set bVBA = New BedvitCOM.VBA 'раннее связывание
'Dim bVBA As Object: Set bVBA = CreateObject("BedvitCOM.VBA") 'позднее связывание
 
Randomize
For x = 0 To 10000
s = s + Format(Rnd() * 10000000000#, "0000000000")
Next
s2 = Format(Rnd() * 100, "00")
Debug.Print "find-"; s2
 
t = Timer
For x = 1 To 10000000
s4 = InStr(s, s2)
Next
Debug.Print "InStr "; Timer - t
 
t = Timer
For x = 1 To 10000000
s4 = bVBA.InStr(s, s2)
Next
Debug.Print "bVBA.InStr "; Timer - t

t = Timer
For x = 1 To 10000
s4 = Replace(s, s2, "333")
Next
Debug.Print "Replace "; Timer - t
 
t = Timer
For x = 1 To 10000
s4 = bVBA.Replace(s, s2, "333")
Next
Debug.Print "bVBA.Replace "; Timer - t
 
End Sub

Результаты:
InStr  6,683594
bVBA.InStr 1,480469

Replace  3,65625
bVBA.Replace  0,765625
Изменено: bedvit - 11.08.2019 15:23:02
«Бритва Оккама» или «Принцип Калашникова»?
 
bedvit, у меня просто слов нет - вы действительно увлечённый своей работой человек!  Спасибо вам огромное!!! 8-0  :idea:
Потрясающие результаты! Честно говоря, никогда бы не поверил, что стандартную InStr можно обогнать каким-либо образом — настолько она кажется "простой" и шустрой (0,5 сек на 1 млн прогонов по строке до 255 символов)… Завтра потестирую на своих данных + в составе других макросов на "работу в команде"  :D
Изменено: Jack Famous - 11.08.2019 16:53:23
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
bedvit, приветствую!

Тесты очень порадовали: по самым грубым подсчётам выигрыш составил от 1,5 (голый InStr) до 6-7 раз (InStrReplace). "В команде" также работает хорошо - заменил некоторые регулярки вашим Replace'ом (например замена двойных символов).
InStr настолько быстрый, что при малейшей вероятности, что в строке может отсутствовать подстрока для Replace, можно смело втыкать проверку типа:
Код
    For Each x In arrSym
        i = bVBA.InStr(iVal, x)
        If i Then iVal = bVBA.Replace(iVal, x, "", i)
    Next x
— то есть тут как раз очень кстати третий параметр Replace, позволяющий просматривать не с начала. Нашли? Знаем где. Не нашли? Не тратим ресурсы Replace и идём дальше. Со штатной, ясное дело, такой фокус не прокатит, т.к. придётся "приклеивать голову" до найденной позиции, что убивает любой выигрыш на корню (я пробовал)…

С другой стороны, макрос ReplaceCheck (откуда пример проверки) показывает, что на 100k элементов разница между прямым вызовом и вызовом с проверкой составляет ~ 200мс, что говорит о крайне высочайшей степени оптимизации! Отшлифовано просто грандиозно!  :idea:
Это результат на arrSym = Array(1, 2, 3, 4), то есть 2 символа есть в строке и 2 нет. Соответственно проверка даст большой выигрыш на arrSym = Array(2, 4) (символы отсутствуют в строке) и мизерный проигрыш на arrSym = Array(1, 3) (символы присутствуют в строке).

Предложение: пытался вот тут сколотить замену штатной Split через вашу Replace, но понял, что для хорошего результата вашему InStr не хватает третьего параметра "с какой позиции смотреть" (прямо как у Replace). Можно ли "прикрутить" его без потери скорости? При необходимости сделать обязательным (не опциональным), если это понадобится…? Уверен, что он для многих целей будет совсем не лишним
Стенд
Изменено: Jack Famous - 12.08.2019 15:19:57
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
 
Jack Famous, приветствую! Спасибо за тесты.
Цитата
Jack Famous написал:
InStr не хватает третьего параметра "с какой позиции смотреть" (прямо как у Replace).
если внимательно посмотреть, то можно его увидеть :)
Скорость моей InStr уже с учетом этого параметра ;-)
Цитата
Jack Famous написал:
ReplaceCheck (откуда пример проверки) показывает, что на 100k элементов разница между прямым вызовом и вызовом с проверкой составляет ~ 200мс, что говорит о крайне высочайшей степени оптимизации! Отшлифовано просто грандиозно!  
да этот момент учтен в реализации Replace.
Изменено: bedvit - 12.08.2019 16:48:51
«Бритва Оккама» или «Принцип Калашникова»?
Страницы: Пред. 1 2 3 След.
Наверх