Stroustrup opublikował ostatnio serię postów obalających popularne mity o C ++ . Piąty mit brzmi: „C ++ jest przeznaczony tylko dla dużych, skomplikowanych programów”. Aby go obalić, napisał prosty program C ++ pobierający stronę internetową i wydobywający z niej linki . Oto on:

#include <string>
#include <set>
#include <iostream>
#include <sstream>
#include <regex>
#include <boost/asio.hpp>

using namespace std;

set<string> get_strings(istream& is, regex pat)
{
    set<string> res;
    smatch m;
    for (string s; getline(is, s);)  // read a line
        if (regex_search(s, m, pat))
            res.insert(m[0]);              // save match in set
    return res;
}

void connect_to_file(iostream& s, const string& server, const string& file)
// open a connection to server and open an attach file to s
// skip headers
{
    if (!s)
        throw runtime_error{ "can't connect\n" };

    // Request to read the file from the server:
    s << "GET " << "http://" + server + "/" + file << " HTTP/1.0\r\n";
    s << "Host: " << server << "\r\n";
    s << "Accept: */*\r\n";
    s << "Connection: close\r\n\r\n";

    // Check that the response is OK:
    string http_version;
    unsigned int status_code;
    s >> http_version >> status_code;

    string status_message;
    getline(s, status_message);
    if (!s || http_version.substr(0, 5) != "HTTP/")
        throw runtime_error{ "Invalid response\n" };

    if (status_code != 200)
        throw runtime_error{ "Response returned with status code" };

    // Discard the response headers, which are terminated by a blank line:
    string header;
    while (getline(s, header) && header != "\r")
        ;
}

int main()
{
    try {
        string server = "www.stroustrup.com";
        boost::asio::ip::tcp::iostream s{ server, "http" };  // make a connection
        connect_to_file(s, server, "C++.html");    // check and open file

        regex pat{ R"((http://)?www([./#\+-]\w*)+)" }; // URL
        for (auto x : get_strings(s, pat))    // look for URLs
            cout << x << '\n';
    }
    catch (std::exception& e) {
        std::cout << "Exception: " << e.what() << "\n";
        return 1;
    }
}

Pokażmy Stroustrupowi, czym tak naprawdę jest mały i czytelny program.

1. Pobieranie http://www.stroustrup.com/C++.html

2. Wyświetl wszystkie linki:

   http://www-h.eng.cam.ac.uk/help/tpl/languages/C++.html
   http://www.accu.org
   http://www.artima.co/cppsource
   http://www.boost.org
   ...
   

Możesz używać dowolnego języka, ale biblioteki innych firm nie są dozwolone.

Zwycięzca

Odpowiedź C ++ wygrana głosami, ale opiera się ona na bibliotece innej firmy (która jest niedozwolona przez zasady), a wraz z innym bliskim konkurentem Bashem opiera się na zhakowanym kliencie HTTP (nie będzie współpracować z HTTPS, gzip, przekierowania itp.). Więc Wolfram jest wyraźnym zwycięzcą. Kolejnym rozwiązaniem, które jest bardzo podobne pod względem wielkości i czytelności, jest PowerShell (z ulepszeniami wynikającymi z komentarzy), ale nie spotkał się on z dużym zainteresowaniem. Języki głównego nurtu ( Python , C # ) również były bardzo podobne.

Wolfram

To jest jak całkowite oszustwo

Import["http://www.stroustrup.com/C++.html", "Hyperlinks"]

Więc po prostu dodaj uczciwe parsowanie na wierzchu

Cases[
 Import["http://www.stroustrup.com/C++.html", "XMLObject"],
 XMLElement["a", {___, "href" -> link_, ___}, ___] :> 
  link /; StringMatchQ[link, RegularExpression["((http://)?www([./#\\+-]\\w*)+)"]]
, Infinity]

C ++

#include <boost/asio.hpp>
#include <regex>
#include <iostream>
int main() {
    std::string server = "www.stroustrup.com";
    std::string request = "GET http://" + server + "/C++.html HTTP/1.0\r\nHost: " + server + "\r\n\r\n";
    boost::asio::ip::tcp::iostream s{server, "http"};
    s << request;
    std::regex pat{R"((http://)?www([./#\+-]\w*)+)"};
    std::smatch m;
    for (std::string l; getline(s, l);)
        if (std::regex_search(l, m, pat))
            std::cout << m[0] << "\n";
}

Główną wadą jest niezręczna natura boost :: asio, jestem pewien, że może być jeszcze krótsza z lepszą biblioteką.

Pure Bash w systemie Linux / OS X (bez narzędzi zewnętrznych)

Oprogramowanie klienckie HTTP jest notorycznie nadęte. Nie chcemy tego rodzaju zależności. Zamiast tego możemy przesunąć odpowiednie nagłówki w dół strumienia TCP i odczytać wynik. Nie trzeba wywoływać archaicznych narzędzi, takich jak grep lub sed, aby przeanalizować wynik.

domain="www.stroustrup.com"
path="C++.html"
exec 3<> /dev/tcp/$domain/80
printf "GET /$path HTTP/1.1\r\nhost: %s\r\nConnection: close\r\n\r\n" "$domain" >&3
while read -u3; do
    if [[ "$REPLY" =~ http://[^\"]* ]]; then
        printf '%s\n' "$BASH_REMATCH"
    fi
done

Meh - przypuszczam, że może być bardziej czytelny ...

Python 2

import urllib2 as u, re
s = "http://www.stroustrup.com/C++.html"
w = u.urlopen(s)
h = w.read()
l = re.findall('"((http)s?://.*?)"', h)
print l

Kulawy, ale działa

DO#

using System;
using System.Net;
using System.Text.RegularExpressions;

class Program {
    static void Main() {
        string html = new WebClient().DownloadString("http://www.stroustrup.com/C++.html");
        foreach (Match match in Regex.Matches(html, @"https?://[^""]+"))
            Console.WriteLine(match);
    }
}

„Żadna strona trzecia” jest błędem

Uważam, że założenie „braku stron trzecich” jest błędem. Jest to szczególny błąd, który dotyka programistów C ++, ponieważ tak trudno jest stworzyć kod wielokrotnego użytku w C ++. Gdy w ogóle coś opracowujesz, nawet jeśli jest to mały skrypt, zawsze będziesz korzystać z wszelkich dostępnych fragmentów kodu wielokrotnego użytku.

Chodzi o to, że w językach takich jak Perl, Python, Ruby (by wymienić tylko kilka) ponowne użycie kodu innej osoby jest nie tylko łatwe, ale tak właśnie większość ludzi faktycznie pisze kod.

C ++, ze swoimi prawie niemożliwymi do utrzymania, kompatybilnymi wymaganiami ABI, sprawia, że ​​praca jest o wiele trudniejsza, kończy się projekt taki jak Boost, który jest monstrualnym repozytorium kodu i bardzo niewielką kompozycją poza nim.

Przykład CPAN

Dla zabawy, oto przykład oparty na CPAN, z poprawnym parsowaniem html, zamiast próby użycia wyrażenia regularnego do parsowania html

#!/usr/bin/perl
use HTML::LinkExtor;
sub callback {
   my ($tag, %links) = @_;
   print map { "$_\n" } values %links
}
$p = HTML::LinkExtor->new(\&callback, "http://www.stroustrup.com/C++.html");

Powłoka UNIX

lynx -dump http://www.stroustrup.com/C++.html | grep -o '\w*://.*'

Znajduje również ftp://link :)

Innym sposobem, bez polegania na ://składni:

lynx -dump -listonly http://www.stroustrup.com/C++.html | sed -n 's/^[ 0-9.]\+//p'

CSS 3

* {
  margin: 0;
  padding: 0;
}
*:not(a) {
  font: 0/0 monospace;
  color: transparent;
  background: transparent !important;
}
a {
  content: "";
}
a[href*="://"]::after {
  content: attr(href);
  float: left;
  clear: left;
  display: block;
  font: 12px monospace;
  color: black;
}

Tego kodu można użyć jako stylu użytkownika do wyświetlania wyłącznie bezwzględnych linków na stronie na niesformatowanej liście. Może nie działać poprawnie, jeśli przeglądarka wymusza minimalny rozmiar czcionki.

Działa poprawnie z http://www.stroustrup.com/C++.html(uwaga !importantna background). Aby pracować na innych stronach z większą liczbą stylów, należy go rozszerzyć (zresetuj więcej właściwości, zaznacz właściwości jako ważne itp.).

Alternatywna wersja, która zawiera linki względne, z wyjątkiem linków intrapage zaczynających się od skrótów (opiera się niestety na bezwzględnym linku bezwzględnym)

* {
  margin: 0;
  padding: 0;
}
*:not(a) {
  font: 0/0 monospace;
  color: transparent;
  background: transparent !important;
  float: none !important;
  width: auto !important;
  border: none !important;
}
a {
  content: "";
}
a::after {
  display: none;
}
a:not([href^="#"])::after {
  content: attr(href);
  float: left;
  clear: left;
  display: block;
  font: 12px monospace;
  color: black;
}
a:not([href*="://"])::after {
  content: "http://www.stroustrup.com/" attr(href);
}

Clojure

(->> (slurp "http://www.stroustrup.com")
     (re-seq #"(?:http://)?www(?:[./#\+-]\w*)+"))

Emacs Lisp

(with-current-buffer (url-retrieve-synchronously "http://www.stroustrup.com/C++.html")
  (while (re-search-forward "https?://[^\\\"]*")
    (print (match-string 0))))

Scala

"""\"(https?://.*?)\"""".r.findAllIn(scala.io.Source.fromURL("http://www.stroustrup.com/C++.html").mkString).foreach(println)

PHP 5

<?php
preg_match_all('/"(https?:\/\/.*?)"/',file_get_contents('http://www.stroustrup.com/C++.html'),$m);
print_r($m[1]);

PowerShell

Wyszukiwanie tekstowe wszystkich w pełni kwalifikowanych adresów URL (w tym JavaScript, CSS itp.):

[string[]][regex]::Matches((iwr "http://www.stroustrup.com/C++.html"), '\w+://[^"]+')

Lub, aby uzyskać linki tylko w tagach zakotwiczonych (obejmuje względne adresy URL):

(iwr "http://www.stroustrup.com/C++.html").Links | %{ $_.href }

Krótsze wersje z komentarzy:

(iwr "http://www.stroustrup.com/C++.html").Links.href

(iwr "http://www.stroustrup.com/C++.html").Links.href-match":"

re

import std.net.curl, std.stdio;
import std.algorithm, std.regex;

void main() {
foreach(_;byLine("http://www.stroustrup.com/C++.html")
    .map!((a)=>a.matchAll(regex(`<a.*?href="(.*)"`)))
    .filter!("a")){ writeln(_.front[1]); }
}

Node.js

var http = require('http');

http.get('http://www.stroustrup.com/C++.html', function (res) {
    var data = '';
    res.on('data', function (d) {
        data += d;
    }).on('end', function () {
        console.log(data.match(/"https?:\/\/.*?"/g));
    }).setEncoding('utf8');
});

Rubin

require 'net/http'
result = Net::HTTP.get(URI.parse('http://www.stroustrup.com/C++.html'))
result.scan(/"((http)s?://.*?)"/)

Haskell

Niektóre problemy z "\w"Text.Regex.Posix

import Network.HTTP
import Text.Regex.Posix
pattern = "((http://)?www([./#\\+-][a-zA-Z]*)+)"
site = "http://www.stroustrup.com/C++.html"

main = do
    file <- getResponseBody =<< simpleHTTP (getRequest site)
    let result = getAllTextMatches $ file =~ pattern
    putStr $ unlines result -- looks nicer

PHP

O ile mi wiadomo, większość nowoczesnych instalacji PHP jest wyposażona w przetwarzanie DOM, więc oto ta, która faktycznie przegląda kotwice wewnątrz HTML:

foreach (@DOMDocument::loadHTMLFile('http://stroustrup.com/C++.html')->getElementsByTagName('a') as $a) {
    if (in_array(parse_url($url = $a->getAttribute('href'), PHP_URL_SCHEME), ['http', 'https'], true)) {
        echo $url, PHP_EOL;
    }
}

Wewnętrzną pętlę można skrócić do:

preg_match('~^https?://~', $url = $a->getAttribute('href')) && printf("%s\n", $url);

Powłoka Unix

wget -q -O - http://www.stroustrup.com/C++.html | sed -n '/http:/s/.*href="\([^"]*\)".*/\1/p' | sort

Chociaż muszę przyznać, że to nie działa, jeśli w linii jest więcej niż jeden link.

Jawa

import java.util.regex.*;
class M{
    public static void main(String[]v)throws Throwable{
        Matcher m = Pattern.compile( "\"((http)s?://.*?)\"" )
            .matcher(
                 new Scanner(
                         new URL( "http://www.stroustrup.com/C++.html" )
                             .openStream(),
                         "UTF-8")
                     .useDelimiter("\\A")
                     .next());
        while(m.find())
            System.out.println(m.group());
    }
}

Groovy

"http://www.stroustrup.com/C++.html".toURL().text.findAll(/https?:\/\/[^"]+/).each{println it}

SQL (SQL Anywhere 16)

Zdefiniuj procedurę przechowywaną, aby pobrać stronę internetową

CREATE OR REPLACE PROCEDURE CPPWebPage()
URL 'http://www.stroustrup.com/C++.html'
TYPE 'HTTP';

Utwórz zestaw wyników za pomocą jednego zapytania

SELECT REGEXP_SUBSTR(Value,'"https?://[^""]+"',1,row_num) AS Link  
FROM (SELECT Value FROM CPPWebPage() WITH (Attribute LONG VARCHAR, Value LONG VARCHAR) 
      WHERE Attribute = 'Body') WebPage, 
      sa_rowgenerator( 1, 256 ) 
WHERE Link IS NOT NULL;

Ograniczenia: Daje to do 256 linków. Jeśli istnieje więcej linków, zwiększ 256 do odpowiedniej wartości.

CoffeeScript / NodeJS

require('http').get 'http://www.stroustrup.com/C++.html', (r) ->
    dt = '';
    r.on 'data', (d) -> dt += d
    r.on 'end' , (d) -> console.log dt.match /"((http)s?:\/\/.*?)"/g

Perl

use LWP;
use feature 'say';

my $agent = new LWP::UserAgent();
my $response = $agent->get('http://www.stroustrup.com/C++.html');

say for $response->content =~ m<"(https?://.+?)">g;

R

html<-paste(readLines("http://www.stroustrup.com/C++.html"),collapse="\n")
regmatches(html,gregexpr("http[^([:blank:]|\\\"|<|&|#\n\r)]+",html))

... chociaż R jest napisany głównie w C ... więc prawdopodobnie kilka linii kodu C za tymi 2 liniami kodu R.

Cel C

NSString *s;
for (id m in [[NSRegularExpression regularExpressionWithPattern:@"\"((http)s?://.*?)\"" options:0 error:nil] matchesInString:(s=[NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.stroustrup.com/C++.html"]])]){
    NSLog(@"%@",[s substringWithRange:[m range]]);
}

Tcl

package require http
set html [http::data [http::geturl http://www.stroustrup.com/C++.html]]
puts [join [regexp -inline -all {(?:http://)?www(?:[./#\+-]\w*)+} $html] \n]

Iść

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "regexp"
)

func main() {
    resp, err := http.Get("http://www.stroustrup.com/C++.html")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    defer resp.Body.Close()
    data, _ := ioutil.ReadAll(resp.Body)
    results := regexp.MustCompile(`https?://[^""]+`).FindAll(data, -1)
    for _, row := range results {
        fmt.Println(string(row))
    }
}

PS ten kod odczytuje całe źródło do pamięci, więc rozważ użycie regexp.FindReaderIndexwyszukiwania w strumieniu, dzięki czemu aplikacja będzie kuloodporna.

CJam

CJam nie ma wyrażenia regularnego, więc w tym przypadku musiałem zastosować inne podejście:

"http://www.stroustrup.com/C++.html"g''/'"*'"/(;2%{_"http://"#!\"https://"#!e|},N*

Najpierw konwertuję wszystko 'na ", następnie dzielę na wszystkie ", biorę każdy alternatywny ciąg, a następnie filtruję tę listę pod kątem ciągów rozpoczynających się od http://lubhttps:// . Następnie po prostu wydrukuj każdy filtrowany ciąg w nowej linii.

Spróbuj, używając interpretera Java, takiego jak

java -jar cjam-0.6.2.jar file.cjam

gdzie plik.cjam ma treść powyższego kodu.

FA#

Ten kod może być znacznie krótszy, ale napisałbym coś takiego, gdybym kiedykolwiek spodziewał się, że będę musiał go przeczytać lub użyć ponownie, aby zawierał wiele niepotrzebnych adnotacji typu. Pokazuje użycie aktywnego wzorca MatchValue, aby umożliwić dopasowanie wzorca do standardowego dopasowania typu CLR

open System.Net

let (|MatchValue|) (reMatch: Match) : string = reMatch.Value

let getHtml (uri : string) : string = 
    use webClient = WebClient() in
        let html : string = webClient.DownloadString(uri)
        html

let getLinks (uri : string) : string list =
    let html : string = getHtml uri
    let matches : MatchCollection = Regex.Matches(html, @"https?://[^""]+") 
    let links = [ for MatchValue reMatch in matches do yield reMatch ]
    links

let links = getLinks "http://www.stroustrup.com/C++.html" 
for link in links do
    Console.WriteLine(link)

Edycja Zrobiłem getLinks własną funkcję