Неделю назад я рассказывал на Хабре про 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 без </li> и </p>. Перед замером каждый бенчмарк проверяет, что все библиотеки вернули одни и те же записи.

  • Время — медиана на вызов после прогрева. В 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 без </li> </p>

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 без </li> </p>

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

Dom\HTMLDocument (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

Dom\HTMLDocument (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 и Dom\HTMLDocument — это 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-дерево с объектом на каждый узел, создают неявные <html> и <tbody>, а потом ещё и заворачивают найденные узлы в объекты 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<char>, векторизованные 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 без </li> </p>

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%

Dom\HTMLDocument (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*'.

Комментарии (62)


  1. v_0ver
    18.11.2026 13:52

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

    в Rust =)


    1. Akon32
      18.11.2026 13:52

      Осталось попробовать делегировать из Python в Java, и, внезапно, получить почти ту же скорость, что и в Rust.


  1. economist75
    18.11.2026 13:52

    Тема с чистым Python осталась не раскрыта. И если скорость наверняка была бы не очень, допустим на уровне Ruby, то число строк вполне могло оказаться 3-4 тыс.

    На практике на чистом Python писать парсер влом, ведь проще использовать что-то готовое (pandas итп) - и вот тут как раз можно здорово сэкономить и строки, и скорость выполнения. То что при этом получится не чистый python абсолютно нормально, но сильно ломает логику и смысл подобных компитишнов.


    1. romanti3172 Автор
      18.11.2026 13:52

      Это всё-таки не компетишн, а скорее промоушн :) Можно и на чистом питоне — https://github.com/romanti3172/fasthtmlparser-pure

      Без C, Rust и зависимостей, API тот же, что у версии с Rust внутри. Со скоростью примерно уровень Ruby, чуть ниже. Та же виндовая виртуалка, что в статье:

      - разбор страницы books (51 КБ): 2,1 мс. У Ruby без JIT — 1,5 мс, у BeautifulSoup с html.parser — 19 мс, у lxml (C) — 1,6 мс;

      - скрапинг 20 книг: 2,6 мс. У BeautifulSoup — 22,5 мс, у lxml — 2,8 мс.

      Выходит, от Ruby отстаёт в 1,2–1,4 раза, BeautifulSoup обгоняет раз в 8–9, а с lxml на скрапинге идёт вровень. Версия с Rust внутри, конечно, быстрее ещё в 20–30 раз, потому в статье и была она.

      Строк вышло ~4 700 руками плюс 2 500 сгенерированной таблицы HTML5-сущностей, так что ваши 3–4 тысячи почти в точку. Тесты те же, что у остальных портов: на 117 страницах и 569 XPath/CSS-запросах всё совпадает с .NET байт в байт. Повторить замер: python bench/bench.py.

      А pandas.read_html, кстати, внутри использует тот же lxml (или BeautifulSoup) и читает только таблицы.


      1. economist75
        18.11.2026 13:52

        Спасибо, вот теперь картинка полная и довольно дружелюбная ко всем участникам. Сейчас такое увидишь редко. Если честно, и не припомню (в рунете).


  1. Siemargl
    18.11.2026 13:52

    А в поддержке франкенштейны в разы хуже. Нужно разбираться в нескольких языках и в нюансах по интеропу.

    Так что забываем про питон, а из остальных трех берём тот, какой лучше знают в рабочей группе.


    1. romanti3172 Автор
      18.11.2026 13:52

      Зависит от объёмов. Если парсить десятки терабайт в день — разница очень ощутима, в деньгах за железо. А если пару страничек — конечно, то, что удобнее команде.


      1. Siemargl
        18.11.2026 13:52

        В твоей же табличке первые 5 результатов нос к носу. Какая там разница?

        Я, кстати ещё бы память смотрел, тот же rss


        1. romanti3172 Автор
          18.11.2026 13:52

          так это не то что нравится, а вполне конкретная одна либа, с портами на разные языки


  1. savostin
    18.11.2026 13:52

    Windows — Windows 10 LTSC в виртуалке KVM

    Похоже на нечестную игру.

    Да и сравнивать микросекунды, когда погрешность измерения уже рядом имхо пальцем в небо.


    1. romanti3172 Автор
      18.11.2026 13:52

      нечестно по отношению к кому, если есть группа сравнений всех кого можно внутри одно и той же виртуалки?


      1. savostin
        18.11.2026 13:52

        не честно запихивать одну OS в виртуалку, а другую - нет.


        1. romanti3172 Автор
          18.11.2026 13:52

          по ним сравнение отдельно идет, отдельно колонка в винде, отдельно в линуксе


  1. romanti3172 Автор
    18.11.2026 13:52

    .


  1. Andreas_Fogel
    18.11.2026 13:52

    Скорее всего говорить, что парсер на расте тут достиг своего пика не стоит. Надо смотреть исходный код и что в нем написано. Если мы уберем логирование и прочий оверхед мусор, будем держать все в стеке и добавим микроаренку с 1 преаллокацией, то раст может раза в 2 или 3 стать быстрее. А это уже быстрее быстрого. Тем более что тут возможно не только avx2 можно будет применить, но и другие инструкции.


    1. romanti3172 Автор
      18.11.2026 13:52

      да тут уже все хорошо

      • Логирования нет вообще. Ни log, ни tracing, ни println. Единственная зависимость — memchr.

      • Преаллокация уже есть, и она лучше одноразовой «микроаренки». В parse.rs:67 сначала считаются все <, это точная верхняя граница числа тегов. Под неё один раз выделяется массив узлов в thread-local scratch-буфере, который переиспользуется между вызовами. На повторных документах аллокаций на теги нет совсем.

      • SIMD уже работает. Горячий цикл ищет символы через memchr/memchr3/memmem. Эти функции сами выбирают AVX2, SSE2 или NEON под процессор.

      • Ленивость. Текст и атрибуты не декодируются при парсинге, только при обращении. Это как раз срезает оверхед


      1. Flux
        18.11.2026 13:52

        Вы же просто напросто не читали "вами же" написанный код, если даже на коммент с хабра не в состоянии ответить сами и пересылаете его агенту.


        1. romanti3172 Автор
          18.11.2026 13:52

          мне так удобней, я еще и посуду в посудомойке мою


          1. Flux
            18.11.2026 13:52

            Во первых, аналогия дерьмовая.

            Во вторых, попытки острить у вас так себе.

            В третьих, ваш вклад в "вашу" кодовую базу нулевой, а предлагать людям тратить время на чтение слопа который вы даже не писали - проявление банального неуважения на границе с хамством.

            Если будете отвечать - попросите агента, естественная речь ему даётся лучше чем вам, как видимо и программирование. И это не комплимент ллмкам.


            1. romanti3172 Автор
              18.11.2026 13:52

              код открыт, если найдёте конкретную проблему, велкам


      1. v_0ver
        18.11.2026 13:52

        Я бы не доверял лошади которая пишет edition = "2021". Я попросил свою лошадь и она достала ещё +5% перформанса, найдя лишние проходы и аллокации:

        Упростил реализацию и сократил лишние аллокации:
        - CSS использует общий итератор; поиск первого совпадения обходится без временного Vec.
        - XPath фильтрует вектор через retain и заимствует строки через Cow.
        - Нормализация строк больше не требует повторной проверки UTF-8.
        - Обработка URL использует truncate вместо копирования промежуточных векторов.
        

        И это без профилирования и доработки общего алгоритма.


        1. romanti3172 Автор
          18.11.2026 13:52

          супер, попросите свою PR создать, 2021 оставлен, чтобы собиралось на компиляторах от 1.80


  1. Flux
    18.11.2026 13:52

    За неделю появились и CSS-селекторы, и XPath 1.0, а сама библиотека переехала ещё на семь языков: Go, Rust, Java, TypeScript, Python, PHP и Ruby.

    В заголовке идет речь про "сравнение языков", хотя на самом деле сравнивалась нейрослопная дрисня которую вряд ли даже читали.

    В чем ценность статьи тогда?


    1. romanti3172 Автор
      18.11.2026 13:52

      Лошадка помогала конечно, восемь портов на разные языки за неделю руками никто не напишет. Но «не читали» — мимо: у всех портов общий набор тестов, каждый XPath/CSS-запрос сверяется с эталоном C#-версии по хэшам

      А смысл как раз в этом: алгоритм везде один и тот же, ведёт себя одинаково, так что разница в цифрах — это разница языков, а не того, кто как написал. Ну и в своих языках оно реально быстрее того, что было до сих пор.


      1. Flux
        18.11.2026 13:52

        Но «не читали» — мимо: у всех портов общий набор тестов, каждый XPath/CSS-запрос сверяется с эталоном C#-версии по хэшам

        Вы немного не то утверждение опровергаете. То что "тесты прошли" не означает что код был вами прочитан, осознан и утвержден.

        так что разница в цифрах — это разница языков, а не того, кто как написал

        Нет, разницей языков это бы было если бы каждую имплементацию писал специалист с учетом знания каждого конкретного языка, его рантайма и библиотеки. В вашем сравнении предполагается что LLM выдала идеальный код для каждого языка (тесты же зеленые), а значит на конечную производительность влияет только сам язык а не качество кода что, разумеется, не верно.


        1. UFO_01
          18.11.2026 13:52

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


    1. svl87
      18.11.2026 13:52

      дело даже не в том что дрисню написал нейрослоп, такие статьи выходили регулярно и до ИИ-эры. было по классике, сравнивали какую-нибудь программу с либой от васяна на C с python-программой с либой написанной на C, а то и с asm вставками, отлаженной и оптимизированной годами. И получали что python быстрее программы на C.

      сейчас в эпоху ИИ не вижу смысла начинать проекты на языках с GC и на языках пропитанных UB, очень слабыми стандартными либами и прочими приколами. В итоге выбора особо-то и не остается, ну вы сами поняли к чем это


      1. UFO_01
        18.11.2026 13:52

        Мы поняли, останется только раст, а так как код всё равно никто не читает, смысла от экспертизы в конкретном языке нет. /s


  1. ImagineTables
    18.11.2026 13:52

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

    Во времена XML считалось само собой, что парсер, который не строит DOM (SAX-парсер), и должен быть быстрее, и кушать меньше памяти, и поэтому быть ещё быстрее. Вот только результат годится для узкого набора задач, типа десериализации настроек.


    1. ris58h
      18.11.2026 13:52

      Вот только результат годится для узкого набора задач

      Это DOM годится для узкого набора задач, где этот DOM преобразуется. Кому это нужно кроме браузера?


      1. ImagineTables
        18.11.2026 13:52

        Virtually any kind of XML validation requires access to the document in full. The most trivial example is that an attribute declared in the DTD to be of type IDREF, requires that there be only one element in the document that uses the same value for an ID attribute. To validate this in a SAX parser, one must keep track of all ID attributes (any one of them might end up being referenced by an IDREF attribute at the very end); as well as every IDREF attribute until it is resolved. Similarly, to validate that each element has an acceptable sequence of child elements, information about what child elements have been seen for each parent must be kept until the parent closes.

        Additionally, some kinds of XML processing simply require having access to the entire document. XSLT and XPath, for example, need to be able to access any node at any time in the parsed XML tree. Editors and browsers likewise need to be able to display, modify, and perhaps re-validate at any time. While a SAX parser may well be used to construct such a tree initially, SAX provides no help for such processing as a whole.

        https://en.wikipedia.org/wiki/Simple_API_for_XML#Drawbacks


        1. romanti3172 Автор
          18.11.2026 13:52

          в цитате, — про потоковую обработку: SAX прошёл документ и забыл. Здесь документ целиком в памяти, с родителями и границами каждого тега, так что XPath как раз и ходит к любому узлу в любой момент — со всеми осями. Чего нет — так это редактирования и DTD-валидации, но для парсинга HTML они и не нужны


          1. ImagineTables
            18.11.2026 13:52

            Я говорил именно про парсинг XML.

            Мне любопытно, а для чего может пригодиться парсинг HTML без построения DOM’а?


            1. romanti3172 Автор
              18.11.2026 13:52

              вытащить со страницы цены, ссылки, карточки товаров, профили, тексты и это десятки терабайт в день на некоторых задачах


              1. ImagineTables
                18.11.2026 13:52

                Ясно, спасибо. Я от скрейпинга далёк и думал, что:

                1. Все магазины сейчас мгновенно банят за, допустим, не скачивание картинок или ещё чего подозрительное. Я заходил в некоторые через обычный Firefox… ну, не совсем обычный, в нём запрещён канвас, доступ к списку шрифтов и ещё кое-что… открывал в отдельной вкладке картинку, не помню — из <img> или из стиля, чтобы сделать zoom 500% и рассмотреть получше, и меня тут же начинали мучить капчей, а потом банили. Разбанивали в ручном режиме, но перед этим просили прислать скриншот. Видимо, чтобы убедиться, что браузер там где-то рядом хотя бы пробегал.

                2. Цены в разметке не отгружают. По крайней мере, Fix Price, потому что когда он меня забанил и api.fix-price давала 403, страница была пустой, это я помню точно.


                1. romanti3172 Автор
                  18.11.2026 13:52

                  В начальной странице цен нет, да. Но если открыть её браузером через автоматизацию, получаешь снимок DOM уже со всем, и это обычный HTML его и парсишь. Антиботы есть, но не везде такие жёсткие.


    1. romanti3172 Автор
      18.11.2026 13:52

      для парсинга DOM не нужен, SAX это потоковый парсинг если что, один раз прочитали и назад не возвращаемся, тут же вполне себе ходим туда обратно по необходимости, у элемента можно получить родительский, соседние элементы, соседние эелементы того же уровня и в таком духе


  1. A1WEB
    18.11.2026 13:52

    Был ли задействован параллелизм?


    1. romanti3172 Автор
      18.11.2026 13:52

      нету параллелизма


  1. UFO_01
    18.11.2026 13:52

    Чистый PHP обгоняет встроенный в PHP 8.4 парсер на C в полтора раза.

    Как минимум тут я скорее поверю что коровы летают, нежели что чистый php обходит lexbor. Подозреваю что вместо построения полноценного DOM дерева использовался прямой поиск нужных тегов.

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

    А, ну это многое объясняет. Кто бы мог подумать что простой парсинг быстрее чем построение DOM дерева.

    Python-версия — это 790 строк обвязки на PyO3 вокруг Rust-версии

    Что там кстати про разницу языков?

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

    Круто конечно, но мы тут вроде реализации на конкретном языке обсуждаем, нет? Ну и круто конечно сравнивать результаты только на учебных полигонах, не посмотрев что на реальных страницах, могли бы и получше клод запрячь.

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

    Так на вопрос не ответили, отвечу за вас: НЕТ.


    1. romanti3172 Автор
      18.11.2026 13:52

      есть и на чистом python'e https://github.com/romanti3172/fasthtmlparser-pure работает уныло


  1. yahooyaks
    18.11.2026 13:52

    Самый быстрый язык тот, у которого компилятор выдаст код с наименьшим количеством тактов за прогон.


  1. Lewigh
    18.11.2026 13:52

    Перед тем как выбирать самый "быстрый язык", неплохо бы было дать определение что автор подразумевает под этим.
    По логике статьи самым быстрым языком может быть bash который запускает исполняемый файл написанный на asm под конкретную платформу. По мне это такой же фарс как Python который просто вызывает библиотеки на C и Rust.

    И тут вопрос очень не простой. По каким критериям можно сказать что именно решения заложенные в той или иной реализации языка быстрее?
    Ну как минимум наверное чтобы сказать что язык быстрее нужно чтобы язык сам выполнил работу.

    Ок. Можно ли использовать все возможности языка или только адекватные? К примеру, можно на Java писать без аллокаций в куче, все храня в пред-выделенных массивах, использовать там свою память и так далее. Вот только эти возможности языка для него самого - это костыли и в целом неестественны, неудобны и выглядят как ахтунг.
    В то же время для C#, тонкая работа с памятью - это абсолютная норма и поддержана удобно на уровне самого языка.

    Такой же вопрос, к примеру, насколько допустимо, например для языка который построен исключительно вокруг GC этот самый GC отключать.

    Ну и разумеется, вопрос с библиотеками. Мы сравниваем языки или в совокупности с отдельными решениями в их экосистемах?

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


    1. Siemargl
      18.11.2026 13:52

      В то же время для C#, тонкая работа с памятью - это абсолютная норма и поддержана удобно на уровне самого языка

      Тат что то появилось кроме stackalloc?


      1. romanti3172 Автор
        18.11.2026 13:52

        много чего: Span/ReadOnlySpan, ref struct, ArrayPool, MemoryMarshal, inline arrays в C# 12, SearchValues в .NET 8 (поиск символов с SIMD под капотом), Vector128/256, все это используется: Span'ы по всему коду, SearchValues и Vector для поиска, буферы из ArrayPool. При этом unsafe и указатели не нужны, всё в рамках обычного безопасного кода


        1. Siemargl
          18.11.2026 13:52

          Понятно. Это все костыли и обвязка вокруг него (стека) .

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


  1. Mox
    18.11.2026 13:52

    Тут тогда не очень понятно почему Python версия - это обертка вокруг Rust, а Ruby - нет


    1. romanti3172 Автор
      18.11.2026 13:52

      в ruby и чистый порт работает отлично, а вот чистый python так себе


  1. misterzsm
    18.11.2026 13:52

    Спасибо за мем в начале - теперь буду знать, какую библиотеку точно не стоит использовать для парсинга html


  1. Rissiamur
    18.11.2026 13:52

    А почему нельзя было написать одну нативную реализацию с логикой на Rust, а затем сделать биндинги на всех других, нужных языках?


    1. romanti3172 Автор
      18.11.2026 13:52

      чистые порты ставятся без компилятора и работают там, где нативное не подцепишь: JS в браузере, PHP на хостинге без своих расширений


      1. cdriper
        18.11.2026 13:52

        JS в браузере

        так WASM же


        1. romanti3172 Автор
          18.11.2026 13:52

          можно и WASM, но там строку на каждый документ надо копировать из JS в память WASM и перекодировать в UTF-8


  1. nagibat0r
    18.11.2026 13:52

    Про Го - очень и очень спорно. Версия на Го заметно хуже оптимизирована. Например, Node почти вдвое тяжелее, после разбора весь массив узлов копируется и очищается, поиск <, = и > сделан простым побайтовым циклом, тогда как в том же Раст и C# используются специализированные процедуры. Замеры не честные


    1. romanti3172 Автор
      18.11.2026 13:52

      пнул ленивую лошадь, выкатил обнову: Node теперь 40 байт вместо 56, поиск символов в теге по 8 байт за раз. Копирование оставил — без него на замерах выходило медленнее, буфер горячий в кэше. А ещё нашёлся поиск имени тега через map. Итого Go-версия стала на 8–11% быстрее и ест на четверть меньше памяти. Спасибо


      1. Siemargl
        18.11.2026 13:52

        Вот скорее всего все тесты надо критически переоценивать после ии.

        Потому что пишет он спустя рукава и делать на этой основе выводы....


        1. romanti3172 Автор
          18.11.2026 13:52

          Для этого код и открыт, после правок цифры сдвинулись на ~10%, а не в разы, так что общая картина та же


  1. squd_akak
    18.11.2026 13:52

    python который делегирует выполнение rust - быстрее чем сам rust - получается python это ускоритель для rust - звучит как стартап.


  1. sanblch
    18.11.2026 13:52

    C++ дает соизмеримые расту цифры


    1. sanblch
      18.11.2026 13:52

      1. romanti3172 Автор
        18.11.2026 13:52

        класс


      1. romanti3172 Автор
        18.11.2026 13:52

        можно быстрее, на 15–25% быстрее в парсинге и в 1,7 раза на XPath ) Основная разница в memchr из MSVC CRT на SSE2. https://github.com/romanti3172/fasthtmlparser-cpp