Какой язык быстрее? Сравнил 8 языков на одной задаче: Python догнал Rust, а Go проиграл даже Java

Неделю назад я рассказывал на Хабре про z3l.FastHtmlParser — HTML-парсер для .NET, который вместо DOM строит плоский список тегов и разбирает страницу в 10–30 раз быстрее HtmlAgilityPack и AngleSharp. Тогда у него не было ни CSS-селекторов, ни XPath, и жил он только в .NET.

За неделю появились и CSS-селекторы, и XPath 1.0, а сама библиотека переехала ещё на семь языков: Go, Rust, Java, TypeScript, Python, PHP и Ruby. Это не «Hello world»: 6–11 тысяч строк в каждой реализации — токенизатор, правила необязательных закрывающих тегов из HTML5, все 2125 именованных сущностей, XPath 1.0 и CSS-селекторы. Алгоритм везде один и тот же, и каждый порт сверяется с оригиналом на одних и тех же страницах.

Семь портов за неделю — это, конечно, не я один. Кто на самом деле вёз телегу, видно по логотипу.

Получился эксперимент, который редко удаётся поставить: одна и та же настоящая задача, восемь языков, две ОС и один и тот же процессор. Значит, можно наконец ответить на вопрос, за который в комментариях убивают. Готовьте вилы.

Условия

  • Одно железо. Физический сервер с AMD Ryzen 7 3800X (8 ядер, 16 потоков).

  • Linux — Ubuntu 26.04 прямо на этом сервере, бенчмарки в Docker, официальные образы: dotnet/sdk:10.0, golang:1.27, rust:1.100, maven:3-eclipse-temurin-21, node:26, python:3.14, php:8.4-cli, ruby:4.0.

  • Windows — Windows 10 LTSC в виртуалке KVM на этом же сервере, 12 vCPU. Версии те же: .NET 10.0.12, Go 1.27.4, Rust 1.100, Java 21.0.13, Node 26.13, Python 3.14.10, PHP 8.4.27, Ruby 4.0.9.

  • PHP — с opcache и tracing JIT на обеих ОС. Ruby — без JIT, а на Linux ещё с YJIT и с новым ZJIT (в сборке RubyInstaller для Windows YJIT нет).

  • Строго по очереди. Ни один бенчмарк не работал одновременно с другим, Linux и Windows — тоже. Сервер боевой: на нём крутятся MySQL, RabbitMQ и десяток сервисов, так что фоновая нагрузка не нулевая (load average 1–3 из 16), зато одинаковая для обеих ОС.

  • Две задачи. Разбор страницы и скрапинг — разбор плюс извлечение 20 книг (название, цена, рейтинг) или 10 цитат. Страницы — сохранённые books.toscrape.com (51 KB), quotes.toscrape.com (11 KB), webscraper.io laptops (38 KB), books ×10 (510 KB) и books без

  • и

    . Перед замером каждый бенчмарк проверяет, что все библиотеки вернули одни и те же записи.

  • Время — медиана на вызов после прогрева. В C# — BenchmarkDotNet, в Go — testing.B (медиана трёх прогонов), в остальных — одинаковый цикл «секунда прогрева, потом партии вызовов, берём медиану».

  • Погрешность — до 10%. Повторные прогоны одного и того же бенчмарка расходились до 10%: C# на books — 55 и 58 μs на Linux, 64 и 59 μs на Windows; Java на Windows — 73 μs вчера и 66 μs сегодня. Поэтому разница меньше 10% в этой статье — ничья.

Результат

Разбор books.toscrape.com, 51 KB (меньше — лучше):

Место

Язык

Linux

Windows

1–4

Python (Rust внутри)

54 μs

67 μs

1–4

C#

55 μs

64 μs

1–4

Rust

56 μs

61 μs

1–4

Java

59 μs

66 μs

5

Go

84 μs

102 μs

6

Node.js (TypeScript)

183 μs

201 μs

7

PHP + JIT

360 μs

516 μs

8

Ruby + YJIT

818 μs

—

9

Ruby

1.60 ms

1.53 ms

Первые четыре места — в пределах погрешности.

Разбор, все страницы — Linux и Windows

Linux:

Страница

Rust

C#

Python

Java

Go

Node.js

PHP

Ruby

Ruby + YJIT

quotes, 11 KB

15 μs

16 μs

17 μs

17 μs

24 μs

65 μs

110 μs

466 μs

240 μs

laptops, 38 KB

46 μs

51 μs

47 μs

62 μs

74 μs

173 μs

303 μs

1.40 ms

1.22 ms

books, 51 KB

56 μs

55 μs

54 μs

59 μs

84 μs

183 μs

360 μs

1.60 ms

818 μs

books ×10, 510 KB

563 μs

611 μs

546 μs

617 μs

857 μs

2.27 ms

3.59 ms

15.3 ms

8.02 ms

books без

52 μs

61 μs

55 μs

63 μs

82 μs

234 μs

390 μs

1.83 ms

1.49 ms

Windows:

Страница

Rust

C#

Python

Java

Go

Node.js

PHP

Ruby

quotes, 11 KB

17 μs

20 μs

18 μs

19 μs

29 μs

68 μs

153 μs

455 μs

laptops, 38 KB

50 μs

54 μs

56 μs

66 μs

88 μs

204 μs

448 μs

1.31 ms

books, 51 KB

61 μs

64 μs

67 μs

66 μs

102 μs

201 μs

516 μs

1.53 ms

books ×10, 510 KB

602 μs

637 μs

654 μs

677 μs

944 μs

2.27 ms

5.11 ms

15.4 ms

books без

55 μs

61 μs

63 μs

71 μs

100 μs

224 μs

514 μs

1.91 ms

Скрапинг 20 книг (разбор + извлечение), Linux / Windows. У каждого порта три способа искать: свои методы Find, CSS-селекторы и XPath.

Язык

Find API

CSS

XPath

Rust

73 / 82 μs

73 / 87 μs

117 / 191 μs

C#

75 / 70 μs

74 / 82 μs

117 / 109 μs

Java

86 / 93 μs

120 / 111 μs

102 / 108 μs

Go

106 / 129 μs

117 / 131 μs

216 / 265 μs

Python

117 / 155 μs

94 / 128 μs

123 / 243 μs

Node.js

230 / 239 μs

285 / 275 μs

269 / 304 μs

PHP

514 / 636 μs

609 / 758 μs

784 / 927 μs

Ruby + YJIT

1.01 ms / —

1.15 ms / —

1.30 ms / —

Ruby

2.08 / 2.14 ms

2.21 / 2.22 ms

3.05 / 2.75 ms

Порты против местных чемпионов

Сравнивать языки между собой весело, но пользователю важнее другое: стоит ли брать порт вместо того, чем уже пользуется его экосистема. Порты писались неделю, и вылизаны они явно меньше оригинала. Вот как они выглядят против лучшего, что было на своих платформах до них.

Разбор books.toscrape.com, 51 KB — во сколько раз порт быстрее (Linux / Windows; меньше 1 — порт медленнее):

Язык

Порт, Linux

Самый быстрый конкурент

Порт быстрее

Популярная альтернатива

Порт быстрее

Rust

56 μs

tl

1.5x / 1.7x

scraper (html5ever)

22x / 25x

C#

55 μs

HtmlAgilityPack

12x / 12x

AngleSharp

21x / 18x

Python

54 μs

selectolax (lexbor, C)

8.4x / 6.3x

BeautifulSoup

226x / 213x

Java

59 μs

Jericho

6.7x / 6.0x

jsoup

8.0x / 7.2x

Go

84 μs

golang.org/x/net/html

10x / 9.6x

goquery

10x / 9.6x

Node.js

183 μs

htmlparser2

5.3x / 4.3x

cheerio

16x / 9.9x

PHP

360 μs

DomHTMLDocument (lexbor, C)

1.5x / 1.5x

DOMDocument (libxml2, C)

2.6x / 2.8x

Ruby + YJIT

818 μs

Nokogiri (libxml2, C)

1.3x / —

Nokogiri

1.3x / —

Ruby

1.60 ms

Nokogiri (libxml2, C)

0.6x / 0.9x

Nokogiri

0.6x / 0.9x

Скрапинг 20 книг — лучший из трёх API порта против лучшего конкурента:

Язык

Порт, Linux

Самый быстрый конкурент

Порт быстрее

Rust

73 μs

tl (CSS)

1.7x / 2.1x

C#

74 μs

HtmlAgilityPack (XPath)

11x / 12x

Python

94 μs

selectolax (CSS)

6.2x / 4.8x

Java

86 μs

jsoup (CSS)

8.2x / 7.5x

Go

106 μs

goquery (CSS)

9.1x / 8.3x

Node.js

230 μs

node-html-parser

6.1x / 4.9x

PHP

514 μs

DomHTMLDocument (CSS)

1.4x / 1.6x

Ruby + YJIT

1.01 ms

Nokogiri (XPath)

1.9x / —

Ruby

2.08 ms

Nokogiri (XPath)

0.9x / 1.1x

В семи языках из восьми порт быстрее всего, что было в экосистеме, — на обеих ОС и в обеих задачах. Причём в Python, PHP и Ruby главные конкуренты написаны на C: selectolax и DomHTMLDocument — это lexbor, lxml, DOMDocument и Nokogiri — libxml2. Чистый PHP обгоняет встроенный в PHP 8.4 парсер на C в полтора раза.

Самый близкий конкурент — tl в Rust, всего в 1.5–2 раза медленнее. Но tl — zero-copy-парсер без декодирования сущностей и без комбинатора потомков в селекторах, то есть делает меньше.

Ruby — особый случай. Без JIT порт идёт вровень с Nokogiri на Windows (разбор на 8% медленнее, скрапинг на 14% быстрее) и проигрывает ей на Linux, где Nokogiri заметно быстрее: в 1.6 раза на разборе. С YJIT порт обгоняет Nokogiri: в 1.3 раза на разборе и в 1.9 раза на скрапинге.

Откуда такой разрыв? C-библиотеки делают в 10 раз больше работы: строят полное DOM-дерево с объектом на каждый узел, создают неявные и

, а потом ещё и заворачивают найденные узлы в объекты Python, PHP или Ruby. Парсер, который хранит теги как пары чисел-смещений в исходной строке, делает ровно то, что нужно для скрапинга, и не больше.

А теперь — почему каждая строчка этих таблиц оскорбит кого-нибудь из читателей.

Тезис 1. Python догнал Rust

На Linux Python разбирает страницу за 54 μs, Rust — за 56. На Windows — 67 и 61.

Конечно, это жульничество: Python-версия — это 790 строк обвязки на PyO3 вокруг Rust-версии. Внутри fh.parse(html) работает не интерпретатор, а тот же машинный код, что и в Rust. А то, что на Linux Python на 2 μs быстрее самого Rust, — это шум и флаги сборки: Python-обёртка собрана с fat LTO, бенчмарк Rust — с thin LTO.

На скрапинге видно, чем платит Python: пересечением границы. Каждый найденный тег и каждая строка становятся объектами Python, и Find-API отстаёт от чистого Rust в 1.6 раза (117 μs против 73). А CSS-селекторы — всего на 30% (94 μs): весь поиск идёт внутри Rust, и граница пересекается один раз. Чем реже код переходит из Python в Rust и обратно, тем ближе он к Rust.

Провокация тут в другом. В споре «Python медленный» обычно забывают, что в продакшене Python и не исполняет горячий код: numpy, pandas, lxml, selectolax, pydantic-core, orjson написаны на C или Rust. Python — это язык, на котором вызывают быстрый код. И если для вашей задачи есть нативное ядро, Python-сервис окажется быстрее «честного» сервиса на Go, который всё делает сам.

Мораль: «быстрый язык» — это часто язык, который удачно делегирует.

Тезис 2. Go — самый медленный из компилируемых

Go разбирает страницу за 84 μs — в полтора раза медленнее Rust, C#, Java и даже Python. На Windows то же самое: 102 μs против 61–67.

При этом Go-версия написана аккуратно: на разбор — 2 аллокации, сборщик мусора в замере почти не участвует. Дело не в GC, а в компиляторе. Компилятор Go сознательно оптимизирует меньше — ради скорости сборки: скромнее инлайнинг, меньше устранённых проверок границ массивов, нет автовекторизации. В Go есть и PGO, но только по заранее снятому профилю (default.pgo), и включают его единицы. А JIT в .NET и HotSpot собирает профиль сам, прямо во время работы, и компилирует под горячие ветки.

Go остаётся прекрасным языком для сервисов — быстрая сборка, простота, предсказуемость. Но «Go быстрый, потому что компилируется» — это миф. Он быстрый относительно Python и Ruby. Не относительно JVM и .NET.

Тезис 3. C# и Java — это почти Rust. А «C# обогнал Rust» — это про Windows

На Linux разбор: C# — 55 μs, Rust — 56, Java — 59. Скрапинг: Rust — 73, C# — 75, Java — 86. Ничья, Java чуть позади.

На Windows картина другая: на скрапинге C# первый — 70 μs против 82 у Rust, а на XPath разрыв почти вдвое: 109 μs против 191. В первом черновике этой статьи заголовок был «C# обогнал Rust». А потом я посмотрел на Linux, где Rust и C# идут вровень, и стал разбираться.

Причина — аллокатор. .NET выделяет объекты в своей куче одинаково на любой ОС: сдвигом указателя. А Rust по умолчанию берёт системный аллокатор: на Linux это malloc из glibc, на Windows — HeapAlloc. XPath-движок создаёт много маленьких векторов и строк, и системная куча Windows на этом проседает. Две строчки — и Rust на Windows переходит на mimalloc:

#[global_allocator]static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

Rust на Windows

HeapAlloc (по умолчанию)

mimalloc

Для сравнения: Linux

Разбор books, 51 KB

61 μs

55 μs

56 μs

Скрапинг, Find API

82 μs

69 μs

73 μs

Скрапинг, XPath

191 μs

125 μs

117 μs

И C# снова не впереди: 70 μs против 69. На Linux mimalloc не меняет ничего (разбор — 55 против 56 μs, XPath — 117 против 117): malloc из glibc для этой нагрузки и так хорош.

Мораль: у языка со сборщиком мусора аллокатор свой и одинаковый везде, а у Rust — тот, что даст ОС. На Windows это стоит Rust до полутора раз.

И ещё о честности: C#-версия — оригинал, и она вылизана сильнее остальных: ArrayPool, Span, векторизованные IndexOfAny, CollectionsMarshal.SetCount, Dictionary.AlternateLookup для поиска по span без аллокации строк. Но и Java-версия, где ничего такого нет, отстаёт от Rust на 5–18%. Если вам нужно «почти как Rust», но без borrow checker’а, — это ваши языки.

Тезис 4. NativeAOT медленнее JIT, а серверный GC не помогает

Раз уж C# в первой четвёрке, проверим, как его ускорить. Две популярные идеи: скомпилировать заранее (NativeAOT) и включить серверный сборщик мусора. BenchmarkDotNet собирал NativeAOT под тот же набор инструкций, что использует JIT на этом процессоре (x86-64-v3, AVX2), так что дело не в нём.

C#, время; в скобках — относительно обычного JIT на той же ОС:

Задача

ОС

JIT

JIT + server GC

NativeAOT

NativeAOT + server GC

Разбор books, 51 KB

Linux

58 μs

66 μs (1.14)

75 μs (1.30)

81 μs (1.40)

Windows

59 μs

64 μs (1.08)

83 μs (1.40)

87 μs (1.47)

Разбор books ×10, 510 KB

Linux

614 μs

625 μs (1.02)

765 μs (1.24)

823 μs (1.34)

Windows

600 μs

626 μs (1.04)

824 μs (1.37)

864 μs (1.44)

Скрапинг 20 книг, Find API

Linux

72 μs

80 μs (1.11)

89 μs (1.24)

100 μs (1.40)

Windows

73 μs

75 μs (1.02)

100 μs (1.36)

104 μs (1.41)

Скрапинг 20 книг, XPath

Linux

121 μs

150 μs (1.24)

153 μs (1.26)

181 μs (1.50)

Windows

129 μs

132 μs (1.02)

156 μs (1.21)

169 μs (1.31)

Скрапинг 10 цитат

Linux

25 μs

27 μs (1.06)

32 μs (1.27)

35 μs (1.41)

Windows

25 μs

26 μs (1.05)

37 μs (1.45)

38 μs (1.50)

NativeAOT медленнее JIT на 20–50%. Главная причина — динамический PGO. JIT в .NET сначала компилирует метод быстро и с замерами, смотрит, какие ветки горячие и какие типы реально приходят в интерфейсные вызовы, и перекомпилирует под это: девиртуализирует вызовы, встраивает горячее, раскладывает код так, чтобы горячий путь шёл подряд. NativeAOT компилирует всё заранее, вслепую. Статический PGO для NativeAOT существует, но им почти никто не пользуется.

Серверный GC медленнее на 2–15%, а на XPath, где аллокаций больше всего, — до 24%. У серверного GC своя куча на каждое ядро и гораздо больший бюджет нулевого поколения: сборок меньше, но новые объекты ложатся в память, которой уже нет в кэше. В однопоточном парсере это чистый проигрыш; серверный GC окупается, когда память одновременно выделяют много потоков.

NativeAOT — это про старт за миллисекунды, компактный деплой и отсутствие JIT в рантайме. Не про пиковую скорость.

Тезис 5. Node.js в 3.3 раза медленнее Rust — и это отличный результат

V8 — чудо инженерии. Динамически типизированный язык с JIT держится в 3.3 раза от Rust на разборе (183 μs против 56) и в 3.1 раза на скрапинге. Ни один другой динамический язык в этой таблице и близко не подошёл: PHP вдвое медленнее Node.js, Ruby с YJIT — в 4.5 раза.

Главный тормоз тут даже не V8, а строки JavaScript: UTF-16, иммутабельные, без дешёвых срезов-представлений. Парсер, построенный на смещениях в исходной строке, хорошо ложится на эту модель — поэтому и разрыв такой небольшой.

Тезис 6. Ruby: YJIT удваивает скорость

Ruby 4.0 на Linux — порт и Nokogiri:

Задача

Порт, без JIT

Порт, ZJIT

Порт, YJIT

Nokogiri (libxml2)

Разбор books, 51 KB

1.60 ms

1.25 ms

818 μs

1.01 ms

Разбор books ×10, 510 KB

15.3 ms

12.1 ms

8.02 ms

9.58 ms

Разбор books без

1.83 ms

1.64 ms

1.49 ms

1.01 ms

Скрапинг 20 книг

2.08 ms

1.42 ms

1.01 ms

1.90 ms

Скрапинг 10 цитат

789 μs

529 μs

375 μs

964 μs

YJIT ускоряет чистый Ruby вдвое и на разборе, и на скрапинге. Новый ZJIT из Ruby 4.0 пока даёт меньше: +28% на разборе и +46% на скрапинге. Nokogiri от JIT не ускоряется вовсе — её горячий код написан на C, — поэтому с YJIT порт на чистом Ruby обгоняет её почти везде.

Исключение — страница без закрывающих тегов: Ruby-версия тратит на ней на 14–25% больше, чем на обычной, а с YJIT — на 80% больше, тогда как Rust, Go и Python разницы не замечают. Есть что оптимизировать.

Обидно за Windows: в сборках RubyInstaller YJIT нет, и там Ruby навсегда остаётся интерпретатором.

Тезис 7. Windows против Linux: виртуалка ни при чём

Windows здесь работает в виртуалке на том же сервере, что и Linux, так что первое подозрение — виртуализация. Rust с mimalloc снимает его: 55 μs в виртуалке Windows и 55 μs на голом железе Linux. Для этой нагрузки виртуализация не стоит почти ничего.

Насколько Windows медленнее Linux на том же железе (разбор books, 51 KB):

Что

Linux

Windows

Windows медленнее на

Rust, системный аллокатор

56 μs

61 μs

9%

Rust + mimalloc

55 μs

55 μs

0%

C# (два прогона)

55–58 μs

59–64 μs

2–17%

Java

59 μs

66 μs

12%

Node.js

183 μs

201 μs

10%

Go

84 μs

102 μs

22%

Python (Rust внутри)

54 μs

67 μs

24%

PHP + JIT

360 μs

516 μs

43%

Ruby

1.60 ms

1.53 ms

−4%

lxml (Python, libxml2)

590 μs

1.51 ms

156%

DomHTMLDocument (PHP, lexbor)

524 μs

777 μs

48%

Nokogiri (Ruby, libxml2)

1.01 ms

1.41 ms

40%

selectolax (Python, lexbor)

455 μs

421 μs

−7%

htmlparser2 (Node.js)

977 μs

870 μs

−11%

Что из этого следует:

  • Рантаймы со своим аллокатором — .NET, JVM, V8 — работают на обеих ОС одинаково, в пределах шума. Это касается и чужих библиотек на них: jsoup и AngleSharp отличаются на 1–3%.

  • Rust и Python-обёртка над Rust проседают на Windows из-за системной кучи (см. тезис 3). На XPath в Python разрыв почти двукратный: 243 μs против 123.

  • Интерпретаторы и C-библиотеки зависят от сборки. Одна из причин в PHP: официальные сборки под Windows делает MSVC, а он не умеет computed goto, поэтому Zend VM там работает в более медленном режиме CALL вместо HYBRID. lxml на Windows в 2.6 раза медленнее, Nokogiri — на 40%. Но бывает и наоборот: selectolax и htmlparser2 на Windows быстрее на 7–11%. Всё решает конкретная сборка конкретной библиотеки.

  • Go на Windows медленнее на 22%, хотя аллокатор у него свой. Объяснения у меня нет — буду рад подсказкам в комментариях.

Отдельная провокация: если ваш сервис на PHP или на Python с lxml крутится на Windows, переезд на Linux даст больше, чем переписывание на другой язык.

Тезис 8. Самый быстрый язык — не самый многословный

Сколько непустых строк заняла одна и та же функциональность:

Язык

Строк

TypeScript

5,950

C#

6,950

Java

7,170

Go

8,800

Ruby

8,900

PHP

10,100

Rust

10,750

Python

790 (обвязка над Rust)

Rust-версия — одна из самых быстрых и самая длинная. Ruby, известный своей лаконичностью, оказался длиннее C# и Java: когда пишешь на Ruby парсер, который должен быть быстрым, идиоматичный Ruby заканчивается и начинается ручная работа с индексами в строке. На TypeScript вышло короче всего.

Оговорки, без которых меня справедливо разнесут

  • Это один алгоритм, один автор и одна задача. Разбор HTML — это работа со строками и ветвлениями; на численных задачах, на многопоточности или на I/O картина может быть другой.

  • Порты оптимизированы неодинаково. C#-версия — оригинал, остальные — недельные порты. В Go и Ruby наверняка осталось что ускорить. Пулреквесты, которые двигают свой язык вверх по таблице, приветствуются.

  • Разные измерительные стенды и шум до 10%. BenchmarkDotNet, testing.B и самописный медианный цикл немного по-разному считают, а сервер не простаивает. Разница в 10% между соседними строками — ничья; разница в 2 раза — нет.

  • Всё по умолчанию. Go без PGO, Rust без target-cpu=native и с системным аллокатором, как в большинстве проектов. Векторизованный поиск символов в Rust (memchr) сам определяет AVX2 во время работы.

  • Python — это Rust. Я это сказал. Чистая Python-реализация была бы в районе Ruby, а то и ниже.

  • Windows — в виртуалке. Для наших парсеров она ничего не стоит (Rust + mimalloc), но библиотекам, которые строят большие DOM-деревья, виртуализация может стоить больше: промахи TLB при двухуровневой трансляции адресов дороже.

  • Однопоточный замер. В многопоточном скрапинге в игру вступят GC, аллокаторы и модель потоков — и серверный GC может показать себя иначе. Это тема отдельной статьи.

Итог

Если для холивара всё-таки нужна одна строчка: на разборе Rust ≈ C# ≈ Java ≈ Python (Rust внутри) > Go > Node.js > PHP > Ruby + YJIT > Ruby.

Но если вы хотите, чтобы ваш скрапер стал быстрее, менять язык — не первое, что стоит делать:

  • Язык при одном и том же алгоритме даёт 1.5 раза между первой четвёркой и Go, 3.3 раза — до Node.js, 6.4 раза — до PHP.

  • Алгоритм внутри одного языка даёт от 1.5 до 226 раз против местных библиотек, причём порты на PHP и Ruby обгоняют библиотеки на C.

  • Настройки рантайма весят почти как язык: NativeAOT вместо JIT — на 20–50% дольше, системный аллокатор Windows — до полутора раз дольше для Rust, Windows вместо Linux — на 43% дольше для PHP.

Структуры данных важнее языка, а рантайм и ОС — почти так же важны, как язык.

Все восемь реализаций и бенчмарки открыты — запускайте на своём железе и присылайте свои цифры. Для C# варианты JIT/NativeAOT и workstation/server GC запускаются одной командой: dotnet run -c Release --project benchmarks/z3l.FastHtmlParser.Benchmarks -- --runtime-variants --filter '*ParseBenchmarks.FastHtmlParser' '*ScrapeBenchmarks.*_FastHtmlParser*'.

  • Первая статья, про C#-версию: https://habr.com/ru/articles/1106746/

  • C# (оригинал): https://github.com/romanti3172/z3l.FastHtmlParser

  • Go: https://github.com/romanti3172/fasthtmlparser

  • Rust: https://github.com/romanti3172/fasthtmlparser-rs

  • Python: https://github.com/romanti3172/fasthtmlparser-py

  • Java: https://github.com/romanti3172/fasthtmlparser-java

  • TypeScript: https://github.com/romanti3172/fasthtmlparser-js

  • PHP: https://github.com/romanti3172/fasthtmlparser-php

  • Ruby: https://github.com/romanti3172/fasthtmlparser-rb

Источник: habr.com

0 0 голоса
Рейтинг новости
1
0
Подписаться
Уведомить о
0 комментариев