HTML'yi ayrıştırmak için normal ifadeler kullanma: neden olmasın?

Askerlerin HTML'den bazı bilgileri almak için regex'i kullandığı stackoverflow'daki her sorunun kaçınılmaz olarak HTML'yi ayrıştırmak için regex kullanmamayacağını söyleyen bir "cevabı" olacaktır.

Neden olmasın? Güzel Çorba gibi alıntı-unquote "gerçek" HTML ayrıştırıcıları olduğunu biliyorum ve güçlü ve kullanışlı olduklarından eminim, ancak sadece basit, hızlı veya kirli bir şey yapıyorsanız, neden birkaç regex ifadeleri işe yarayacak zaman çok karmaşık bir şey kullanmak rahatsız?

Dahası, regex hakkında anlamadığım temel bir şey var mı, bu da onları genel olarak ayrıştırmak için kötü bir seçim haline getiriyor mu?

Normal ifadelerde HTML ayrıştırma işleminin tamamı mümkün değildir, çünkü regexps ile mümkün olmayan açılış ve kapanış etiketinin eşleştirilmesine bağlıdır.

Normal ifadeler yalnızca normal dillerle eşleşebilir , ancak HTML bağlamsız bir dildir ve normal bir dil değildir (@StefanPochmann'ın işaret ettiği gibi, normal diller de bağlamsızdır, bu nedenle bağlamdan bağımsız olarak düzenli olmak zorunda değildir). HTML'deki regexps ile yapabileceğiniz tek şey sezgisel taramadır, ancak bu her koşulda işe yaramaz. Herhangi bir normal ifade ile yanlış eşleştirilecek bir HTML dosyası sunmak mümkün olmalıdır.

Quick´n´dirty için normal ifade iyi olur. Ancak bilinmesi gereken temel şey, HTML'yi doğru bir şekilde ayrıştıracak bir regexp oluşturmanın imkansız olmasıdır .

Bunun nedeni normal ifadelerin keyfi olarak iç içe ifadeleri işleyememesidir. Bkz. Normal ifadeler, iç içe geçmiş kalıplarla eşleşmek için kullanılabilir mi?

( Http://htmlparsing.com/regexes adresinden )

<img> etiketlerinden URL'leri çıkarmaya çalıştığınız bir HTML dosyanız olduğunu varsayalım.

<img src="http://example.com/whatever.jpg">

Yani Perl'de böyle bir regex yazıyorsunuz:

if ( $html =~ /<img src="(.+)"/ ) {
    $url = $1;
}

Bu durumda, $urlgerçekten içerecektir http://example.com/whatever.jpg. Ancak şu şekilde HTML almaya başladığınızda ne olur:

<img src='http://example.com/whatever.jpg'>

veya

<img src=http://example.com/whatever.jpg>

veya

<img border=0 src="http://example.com/whatever.jpg">

veya

<img
    src="http://example.com/whatever.jpg">

ya da yanlış pozitifler almaya başlıyorsunuz

<!-- // commented out
<img src="http://example.com/outdated.png">
-->

Çok basit görünüyor ve tek, değişmeyen bir dosya için basit olabilir, ancak keyfi HTML verilerinde yapacağınız her şey için, normal ifadeler gelecekteki kalp ağrısı için bir reçetedir.

İki hızlı neden:

• kötü niyetli girdilere dayanabilecek bir normal ifade yazmak zordur; önceden oluşturulmuş bir araç kullanmaktan çok daha zor
• kaçınılmaz olarak sıkışıp kalacağınız saçma işaretleme ile çalışabilecek bir normal ifade yazmak zordur; önceden oluşturulmuş bir araç kullanmaktan çok daha zor

Normal ifadelerin ayrıştırma için uygunluğuna ilişkin olarak: bunlar uygun değildir. Çoğu dili ayrıştırmak için ihtiyaç duyduğunuz tür regexleri gördünüz mü?

Ayrıştırma ile ilgili olarak, girdilerin jetonlara ayrıldığı "sözcüksel analiz" (lexer) aşamasında düzenli ifadeler yararlı olabilir. Gerçek "ayrıştırma ağacı oluşturma" aşamasında daha az kullanışlıdır.

Bir HTML ayrıştırıcı için, yalnızca iyi biçimlendirilmiş HTML'yi kabul etmesini beklerim ve bu, normal bir ifadenin yapabileceklerinin dışında yetenekler gerektirir ("sayamazlar" ve belirli sayıda açılış öğesinin aynı sayı ile dengelendiğinden emin olurlar) kapatma elemanları).

Tarayıcıların oldukça liberal bir şekilde ele alacağı HTML'yi "sıkıştırmanın" birçok yolu olduğundan, düzenli ifadelerle tüm durumları kapsamak için tarayıcının liberal davranışını yeniden oluşturmak oldukça çaba gerektirecektir, bu nedenle normal ifadeniz bazı özel durumlarda kaçınılmaz olarak başarısız olacaktır. ve sisteminizde ciddi güvenlik boşlukları oluşmasına neden olabilir.

Sorun, HTML ve regex ile ilgili bir soru soran çoğu kullanıcının, çalışan kendi regex'i bulamadıkları için bunu yapmasıdır. Daha sonra bir DOM veya SAX ayrıştırıcısı veya benzeri bir şey kullanırken her şeyin daha kolay olup olmayacağını düşünmek gerekir. XML benzeri belge yapılarıyla çalışmak için optimize edilmiş ve oluşturulmuştur.

Elbette, düzenli ifadelerle kolayca çözülebilecek sorunlar var. Ama vurgu kolayca yatıyor .

Yalnızca http://.../normal ifadelerle iyi görünen tüm URL'leri bulmak istiyorsanız . Ancak, 'mylink' sınıfına sahip bir a-Elementindeki tüm URL'leri bulmak istiyorsanız, muhtemelen uygun bir ayrıştırıcı kullanmanız daha iyi olur.

Düzenli ifadeler, iç içe bir etiket yapısını işlemek için tasarlanmamıştır ve gerçek HTML ile elde edebileceğiniz olası tüm uç durumları işlemek en iyi ihtimalle (en kötü ihtimalle, imkansız) karmaşıktır.

Cevabın hesaplama teorisinde olduğuna inanıyorum. Bir dilin normal ifade kullanılarak ayrıştırılabilmesi için "normal" ( bağlantı ) tanımına göre olması gerekir . HTML, normal bir dil için bir dizi kriteri karşılamadığı için normal bir dil değildir (html kodunda bulunan birçok iç içe yerleştirme düzeyi ile ilgilidir). Eğer hesaplama teorisi ile ilgileniyorsanız bu kitabı tavsiye ederim .

Bu ifade, HTML öğelerinden öznitelikleri alır. Destekler:

• alıntılanmamış / alıntılanmış özellikler,
• tek / çift tırnak,
• özniteliklerin içinde kaçan alıntılar,
• çevresindeki boşluklar eşittir işaretler,
• herhangi bir sayıda özellik,
• yalnızca etiketlerin içindeki özellikleri kontrol edin,
• yorumlardan kaç ve
• bir özellik değeri içindeki farklı tırnak işaretlerini yönetebilir.

(?:\<\!\-\-(?:(?!\-\-\>)\r\n?|\n|.)*?-\-\>)|(?:<(\S+)\s+(?=.*>)|(?<=[=\s])\G)(?:((?:(?!\s|=).)*)\s*?=\s*?[\"']?((?:(?<=\")(?:(?<=\\)\"|[^\"])*|(?<=')(?:(?<=\\)'|[^'])*)|(?:(?!\"|')(?:(?!\/>|>|\s).)+))[\"']?\s*)

Şuna bir bak . Demoda olduğu gibi "gisx" bayraklarıyla daha iyi çalışır.

HTML / XML biçimlendirme ve içeriğe ayrılmıştır. Normal ifade yalnızca sözlüksel etiket ayrıştırma işlemi yaparken kullanışlıdır. Sanırım içeriği çıkarabilirsin. Bir SAX ayrıştırıcı için iyi bir seçim olacaktır. Etiketler ve içerik, öğelerin iç içe yerleştirilmesinin / kapatılmasının takip edilebildiği kullanıcı tanımlı bir işleve iletilebilir.

Etiketleri ayrıştırmakla birlikte, normal ifade ile yapılabilir ve bir belgedeki etiketleri çıkarmak için kullanılabilir.

Yıllarca süren testlerde, tarayıcıların etiketleri iyi ayrıştırmalarının ve kötü şekillendirilmesinin sırrını buldum.

Normal elemanlar bu formla ayrıştırılır:

Bu etiketlerin çekirdeği bu normal ifadeyi kullanıyor

 (?:
      " [\S\s]*? " 
   |  ' [\S\s]*? ' 
   |  [^>]? 
 )+

Bunu [^>]?alternatiflerden biri olarak göreceksiniz . Bu, kötü biçimlendirilmiş etiketlerdeki dengesiz tekliflerle eşleşir.

Aynı zamanda, tüm kötülüklerin düzenli ifadelere tek köküdür . Kullanılma şekli, açgözlü, eşleşmesi gereken nicelikli kabı karşılamak için bir çarpma tetikleyecektir.

Pasif olarak kullanılırsa, asla bir sorun yoktur. Ancak, bir şeyi istenen bir özellik / değer çifti ile serpiştirerek eşleştirmeye zorlarsanız ve geri izlemeye karşı yeterli koruma sağlamazsanız, bu kontrolden çıkmış bir kabus olur.

Bu sadece düz eski etiketler için genel formdur. Uyarı [\w:]etiket adı temsil eden? Gerçekte, etiket adını temsil eden yasal karakterler Unicode karakterlerin inanılmaz bir listesidir.

 <     
 (?:
      [\w:]+ 
      \s+ 
      (?:
           " [\S\s]*? " 
        |  ' [\S\s]*? ' 
        |  [^>]? 
      )+
      \s* /?
 )
 >

Devam ederken, TÜM etiketleri ayrıştırmadan belirli bir etiketi arayamayacağınızı da görüyoruz . Demek istediğim, ama (* SKIP) (* FAIL) gibi fiillerin bir kombinasyonunu kullanmak zorunda kalacaktı, ancak yine de tüm etiketler ayrıştırılmalıdır.

Bunun nedeni, etiket sözdiziminin diğer etiketlerin vb. İçine gizlenmiş olabilmesidir.

Bu nedenle, tüm etiketleri pasif olarak ayrıştırmak için aşağıdaki gibi bir normal ifadeye ihtiyaç vardır. Bu özel içerik de görünmez içerikle eşleşiyor .

Yeni HTML veya xml veya başka herhangi bir yeni yapı geliştirdikçe, alternatiflerden biri olarak ekleyin.

Web sayfası notu - Hiç sorun yaşamadığım bir web sayfası (veya xhtml / xml) görmedim
. Birini bulursan bana haber ver.

Performans notu - Hızlı. Bu gördüğüm en hızlı etiket ayrıştırıcısıdır
(daha hızlı olabilir, kim bilir).
Birkaç özel versiyonum var. Ayrıca kazıyıcı olarak mükemmeldir
(eğer el tipi iseniz).

Tam ham regex

<(?:(?:(?:(script|style|object|embed|applet|noframes|noscript|noembed)(?:\s+(?>"[\S\s]*?"|'[\S\s]*?'|(?:(?!/>)[^>])?)+)?\s*>)[\S\s]*?</\1\s*(?=>))|(?:/?[\w:]+\s*/?)|(?:[\w:]+\s+(?:"[\S\s]*?"|'[\S\s]*?'|[^>]?)+\s*/?)|\?[\S\s]*?\?|(?:!(?:(?:DOCTYPE[\S\s]*?)|(?:\[CDATA\[[\S\s]*?\]\])|(?:--[\S\s]*?--)|(?:ATTLIST[\S\s]*?)|(?:ENTITY[\S\s]*?)|(?:ELEMENT[\S\s]*?))))>

Biçimlendirilmiş görünüm

 <
 (?:
      (?:
           (?:
                # Invisible content; end tag req'd
                (                             # (1 start)
                     script
                  |  style
                  |  object
                  |  embed
                  |  applet
                  |  noframes
                  |  noscript
                  |  noembed 
                )                             # (1 end)
                (?:
                     \s+ 
                     (?>
                          " [\S\s]*? "
                       |  ' [\S\s]*? '
                       |  (?:
                               (?! /> )
                               [^>] 
                          )?
                     )+
                )?
                \s* >
           )

           [\S\s]*? </ \1 \s* 
           (?= > )
      )

   |  (?: /? [\w:]+ \s* /? )
   |  (?:
           [\w:]+ 
           \s+ 
           (?:
                " [\S\s]*? " 
             |  ' [\S\s]*? ' 
             |  [^>]? 
           )+
           \s* /?
      )
   |  \? [\S\s]*? \?
   |  (?:
           !
           (?:
                (?: DOCTYPE [\S\s]*? )
             |  (?: \[CDATA\[ [\S\s]*? \]\] )
             |  (?: -- [\S\s]*? -- )
             |  (?: ATTLIST [\S\s]*? )
             |  (?: ENTITY [\S\s]*? )
             |  (?: ELEMENT [\S\s]*? )
           )
      )
 )
 >

Yine de "bağlıdır". Normal ifadelerin, burada verilen tüm nedenlerden dolayı HTML'yi gerçek doğrulukla ayrıştırmadığı ve ayrıştıramadığı doğrudur. Bununla birlikte, yanlış anlamanın sonuçları (iç içe etiketlerin işlenmemesi gibi) küçükse ve regex'ler ortamınızda (Perl'i hacklediğinizde olduğu gibi) süper uygunsa, devam edin.

Sitenize bağlantı veren web sayfalarını - belki de bir Google bağlantı aramasıyla bulduğunuz - ayrıldığınızı ve bağlantınızı çevreleyen bağlam hakkında genel bir fikir edinmek için hızlı bir yol istediğinizi varsayalım. Spam gibi bir bağlantı oluşturmanız konusunda sizi uyarabilecek küçük bir rapor çalıştırmaya çalışıyorsunuz.

Bu durumda, bazı belgelerin yanlış hazırlanması büyük bir sorun olmayacaktır. Sizden başka kimse hataları görmeyecek ve eğer çok şanslıysanız, bireysel olarak takip edebileceğiniz kadar az olacaktır.

Sanırım bunun bir ödünleşme olduğunu söylüyorum. Bazen doğruluk kritik değilse, doğru bir ayrıştırıcıyı uygulamak veya kullanmak - olabildiğince kolay - sorun yapmaya değmeyebilir.

Sadece varsayımlarınıza dikkat edin. Örneğin, herkese açık olarak gösterilecek bir şeyi ayrıştırmaya çalışıyorsanız normal ifade kısayolunun geri tepebileceği birkaç yolu düşünebilirim.

HTML'den bazı bilgileri ayrıştırmak için normal bir ifade kullanmanın doğru yol olduğu kesin durumlar vardır - bu, belirli duruma çok bağlıdır.

Yukarıdaki fikir birliği, genel olarak kötü bir fikir olduğudur. Bununla birlikte, HTML yapısı biliniyorsa (ve değişmesi olası değilse), hala geçerli bir yaklaşımdır.

HTML'nin kendisi düzenli olmasa da , baktığınız bir sayfanın bölümlerinin düzenli olabileceğini unutmayın .

Örneğin, <form>etiketlerin iç içe yerleştirilmesi bir hatadır ; web sayfası düzgün çalışıyorsa, a almak için normal bir ifade kullanmak <form>tamamen makul olacaktır.

Son zamanlarda sadece Selenyum ve düzenli ifadeler kullanarak bazı web kazıma yaptım. İstediğim veriler kondu çünkü yakalanmadı <form>ve (ben bile güvenebileceğim böylece basit bir tablo biçiminde koymak <table>, <tr>ve <td>- aslında son derece sıradışı olan olmayan iç içe olmak). Bir dereceye kadar düzenli ifadeler neredeyse gerekliydi, çünkü erişmem gereken yapının bir kısmı yorumlar tarafından sınırlandırıldı. (Güzel Çorba size yorum yapabilir, ancak Güzel Çorba kullanarak kapmak <!-- BEGIN -->ve <!-- END -->bloklamak zor olurdu .)

İç içe geçmiş tablolar hakkında endişelenmem gerekirse, yaklaşımım işe yaramazdı! Güzel Çorba'ya geri dönmek zorunda kalırdım. Ancak o zaman bile, bazen ihtiyacınız olan parçayı almak için düzenli bir ifade kullanabilir ve daha sonra oradan ayrıntıya inebilirsiniz.

Aslında, regex ile HTML ayrıştırma PHP'de mükemmel bir şekilde mümkündür. Yuvalanmış etiketleri almak için her seferinde ungreedy belirteçleri kullanarak normal ifadeyi strrposbulmak <ve tekrarlamak için kullanarak tüm dizeyi geriye doğru ayrıştırmanız yeterlidir. Süslü ve büyük şeylerde çok yavaş değil, ancak web sitem için kendi kişisel şablon düzenleyicim için kullandım. Aslında HTML'yi ayrıştırmıyordum, ancak veri tablolarını görüntülemek için veritabanı girişlerini sorgulamak için yaptığım birkaç özel etiket ( <#if()>etiketim bu şekilde özel girişleri vurgulayabilir). Burada ve orada sadece birkaç kendi içinde oluşturulan etiketleri (içinde çok XML olmayan veriler ile) bir XML ayrıştırıcı gitmek hazır değildi.

Bu nedenle, bu soru oldukça ölü olsa da, yine de bir Google aramasında ortaya çıkıyor. Ben okudum ve "meydan kabul kabul" düşündüm ve her şeyi değiştirmek zorunda kalmadan basit kodumu düzeltmeyi bitirdi. Benzer bir sebep arayan herkese farklı bir fikir sunmaya karar verdim. Ayrıca son cevap 4 saat önce yayınlanmıştır, bu yüzden bu hala sıcak bir konudur.

Ben de bunun için bir regex elimi denedim. Çoğunlukla bir sonraki HTML etiketiyle eşleştirilen içerik parçalarını bulmak için yararlıdır ve eşleşen yakın etiketleri aramaz , ancak yakın etiketleri alır. Bunları kontrol etmek için bir yığını kendi dilinizde yuvarlayın.

'Sx' seçenekleriyle kullanın. 'g' şanslı hissediyorsanız:

(?P<content>.*?)                # Content up to next tag
(?P<markup>                     # Entire tag
  <!\[CDATA\[(?P<cdata>.+?)]]>| # <![CDATA[ ... ]]>
  <!--(?P<comment>.+?)-->|      # <!-- Comment -->
  </\s*(?P<close_tag>\w+)\s*>|  # </tag>
  <(?P<tag>\w+)                 # <tag ...
    (?P<attributes>
      (?P<attribute>\s+
# <snip>: Use this part to get the attributes out of 'attributes' group.
        (?P<attribute_name>\w+)
        (?:\s*=\s*
          (?P<attribute_value>
            [\w:/.\-]+|         # Unquoted
            (?=(?P<_v>          # Quoted
              (?P<_q>['\"]).*?(?<!\\)(?P=_q)))
            (?P=_v)
          ))?
# </snip>
      )*
    )\s*
  (?P<is_self_closing>/?)   # Self-closing indicator
  >)                        # End of tag

Bu Python için tasarlanmıştır (diğer diller için işe yarayabilir, denememiş olabilir, pozitif ileriye dönük, negatif geriye dönük ve geri referanslar kullanır). Destekler:

• Etiketi Aç - <div ...>
• Etiketi Kapat - </div>
• Yorum Yap - <!-- ... -->
• CDATA - <![CDATA[ ... ]]>
• Kendiliğinden Kapanan Etiket - <div .../>
• İsteğe Bağlı Özellik Değerleri - <input checked>
• Sıralanmamış / Alıntılanmış Özellik Değerleri - <div style='...'>
• Tek / Çift Tırnaklar - <div style="...">
• Kaçan Tırnaklar - <a title='John\'s Story'>
  (bu gerçekten geçerli bir HTML değil, ama iyi biriyim)
• Etrafındaki Boşluklar İşaretlere Eşittir - <a href = '...'>
• İlginç Bitler İçin Adlandırılmış Yakalamalar

Ayrıca değil bir unuttuğunuzda gibi hatalı oluşturulmuş etiketlere tetikleme konusunda oldukça iyi <veya >.

Regex lezzetiniz tekrarlanan adlandırılmış yakalamaları destekliyorsa, o zaman altınsınız, ancak Python re(regex'in yaptığını biliyorum, ancak vanilya Python kullanmam gerekiyor). İşte elde ettiğiniz:

• content- Bir sonraki etikete kadar tüm içerik. Bunu dışarıda bırakabilirsin.
• markup - İçinde her şeyin olduğu etiketin tamamı.
• comment - Bu bir yorumsa, yorum içeriği.
• cdata- A ise <![CDATA[...]]>, CDATA içeriği.
• close_tag- Yakın etiket ( </div>) ise etiket adı.
• tag- Açık bir etiketse ( <div>), etiket adı.
• attributes- Etiketteki tüm özellikler. Tekrarlanan gruplar almazsanız tüm nitelikleri almak için bunu kullanın.
• attribute - Tekrarlanan her özellik.
• attribute_name - Her özellik adı tekrarlanır.
• attribute_value- Her öznitelik değeri tekrarlanır. Buna, alıntılanmışsa tırnak işaretleri de dahildir.
• is_self_closing- Bu /kendiliğinden kapanan bir etiketse, aksi takdirde hiçbir şey değildir.
• _qve _v- Bunları dikkate almayın; dahili referanslar için kullanılırlar.

Normal ifade motorunuz tekrarlanan adlandırılmış yakalamaları desteklemiyorsa, her bir özelliği almak için kullanabileceğiniz bir bölüm vardır. Sadece o regex çalıştırmak attributesher almak için gruptan attribute, attribute_nameve attribute_valuebunun dışında.

Burada demo: https://regex101.com/r/mH8jSu/11

Normal ifadeler, HTML gibi bir dil için yeterince güçlü değildir. Elbette, düzenli ifadeleri kullanabileceğiniz bazı örnekler var. Ancak genel olarak ayrıştırma için uygun değildir.

Sen orada senin zihniyetin çok benziyor ... biliyorum CAN NOT bunu ve ben çitin her iki tarafında herkesin doğru ve yanlış olduğunu düşünüyorum. Sen CAN bunu, ama biraz daha adil buna karşı bir regex çalışan daha işleme alır. Al bu bir örnek olarak (Bir saat bu iç yazdım). HTML'nin tamamen geçerli olduğunu varsayar, ancak yukarıda belirtilen regex'i uygulamak için hangi dili kullandığınıza bağlı olarak, başarılı olmasını sağlamak için HTML'nin bazı düzeltmelerini yapabilirsiniz. Örneğin, orada olması gerekmeyen kapanış etiketlerinin kaldırılması: </img>örneğin. Ardından, onları eksik olan öğelere kapatma tekli HTML eğik çizgisini ekleyin.

Bunu [x].getElementsByTagName(), örneğin JavaScript'inki gibi HTML öğesi alma işlemini gerçekleştirmeme izin verecek bir kütüphane yazma bağlamında kullanırdım . Normal ifadenin DEFINE bölümüne yazdığım işlevselliği eklerdim ve bir kerede bir element ağacının içine adım atmak için kullanırdım.

Peki, bu HTML'yi doğrulamak için son% 100 cevap olacak mı? Hayır. Ama bu bir başlangıç ​​ve biraz daha çalışma ile yapılabilir. Bununla birlikte, bunu bir regex yürütmesi içinde yapmaya çalışmak pratik ya da verimli değildir.