Stroustrup hat kürzlich eine Reihe von Posts veröffentlicht, in denen beliebte Mythen über C ++ entlarvt werden . Der fünfte Mythos lautet: „C ++ ist nur für große, komplizierte Programme“. Um es zu entlarven, schrieb er ein einfaches C ++ - Programm, das eine Webseite herunterlud und Links daraus extrahierte . Hier ist es:

#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;
    }
}

Zeigen wir Stroustrup, was für ein kleines und lesbares Programm das ist.

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

2. Alle Links auflisten:

   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
   ...
   

Sie können eine beliebige Sprache verwenden, Bibliotheken von Drittanbietern sind jedoch nicht zulässig.

Gewinner

Die C ++ - Antwort, die durch Stimmen gewonnen wurde, basiert auf einer Bibliothek eines halben Drittanbieters (die von den Regeln nicht zugelassen ist) und zusammen mit einem anderen engen Konkurrenten, Bash , auf einem gemeinsam gehackten HTTP-Client (dies funktioniert nicht mit HTTPS). gzip, Weiterleitungen usw.). Damit ist Wolfram ein klarer Sieger. Eine andere Lösung, die in Bezug auf Größe und Lesbarkeit sehr nahe kommt, ist PowerShell (mit Verbesserungen gegenüber Kommentaren), die jedoch nicht viel Aufmerksamkeit erhalten hat. Mainstream-Sprachen ( Python , C # ) kamen auch ziemlich nahe.

Wolfram

Das fühlt sich an wie völliges Betrügen

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

Fügen Sie einfach ehrliches Parsen hinzu

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";
}

Das größte Manko ist die peinliche Art von boost :: asio. Ich bin mir sicher, dass es mit einer besseren Bibliothek noch kürzer sein kann.

Pure Bash unter Linux / OS X (keine externen Dienstprogramme)

HTTP-Client-Software ist notorisch aufgebläht. Wir wollen solche Abhängigkeiten nicht. Stattdessen können wir die entsprechenden Header in einem TCP-Stream ablegen und das Ergebnis lesen. Es müssen keine archaischen Hilfsprogramme wie grep oder sed aufgerufen werden, um das Ergebnis zu analysieren.

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 - ich nehme an, es könnte besser lesbar sein ...

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

Lahm, aber funktioniert

C #

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);
    }
}

"Kein Dritter" ist ein Irrtum

Ich denke, dass die Annahme, dass kein Dritter beteiligt ist, ein Trugschluss ist. Und es ist ein spezifischer Irrtum, der C ++ - Entwickler betrifft, da es so schwierig ist, wiederverwendbaren Code in C ++ zu erstellen. Wenn Sie überhaupt etwas entwickeln, selbst wenn es sich um ein kleines Skript handelt, verwenden Sie immer den wiederverwendbaren Code, der Ihnen zur Verfügung steht.

In Sprachen wie Perl, Python, Ruby (um nur einige zu nennen) ist die Wiederverwendung des Codes eines anderen nicht nur einfach, sondern es ist auch so, wie die meisten Leute den Code die meiste Zeit tatsächlich schreiben.

C ++, mit seinen fast unmöglich zu wartenden kompatiblen ABI-Anforderungen, macht dies zu einer viel härteren Aufgabe. Am Ende haben Sie ein Projekt wie Boost, das eine ungeheure Sammlung von Code darstellt und nur sehr wenig komponierbar ist.

Ein CPAN-Beispiel

Nur zum Spaß finden Sie hier ein CPAN-basiertes Beispiel mit einer korrekten Syntaxanalyse des HTML-Codes, anstatt zu versuchen, Regex zum Parsen des HTML-Codes zu verwenden

#!/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");

UNIX-Shell

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

Findet auch einen ftp://Link :)

Ein anderer Weg, ohne sich auf die ://Syntax zu verlassen:

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;
}

Dieser Code kann als Benutzerstil verwendet werden, um nur absolute Links auf einer Seite in einer unformatierten Liste anzuzeigen. Möglicherweise funktioniert es nicht richtig, wenn Ihr Browser die Mindestschriftgröße erzwingt.

Es funktioniert korrekt mit http://www.stroustrup.com/C++.html(Anmerkung !importantan background). Um auf anderen Seiten mit mehr Stilen arbeiten zu können, muss diese erweitert werden (mehr Eigenschaften zurücksetzen, Eigenschaften als wichtig markieren usw.).

Alternative Version, die relative Links enthält, mit Ausnahme von Intrapage-Links, die mit Hashes beginnen (sie basieren leider auf einem fest codierten absoluten Link):

* {
  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]);

Power Shell

Textsuche für alle vollqualifizierten URLs (einschließlich JavaScript, CSS usw.):

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

Oder um Links nur in Ankertags abzurufen (einschließlich relativer URLs):

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

Kürzere Versionen von Kommentaren:

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

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

D

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

Einige Probleme mit "\w"in 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

Soweit ich das beurteilen kann, kommen die meisten modernen PHP-Installationen mit DOM-Verarbeitung daher. Hier ist eine, die die Anker im HTML-Code tatsächlich durchläuft:

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;
    }
}

Die innere Schleife könnte verkürzt werden auf:

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

Unix-Shell

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

Obwohl ich zugeben muss, dass dies nicht funktioniert, wenn mehr als ein Link in einer Zeile steht.

Java

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)

Definieren Sie eine gespeicherte Prozedur zum Abrufen der Webseite

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

Erstellen Sie die Ergebnismenge mit einer einzigen Abfrage

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;

Einschränkungen: Dies erzeugt bis zu 256 Links. Wenn weitere Links vorhanden sind, erhöhen Sie die 256 auf einen geeigneten Wert.

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))

... obwohl R hauptsächlich in C geschrieben ist ... also wahrscheinlich ein paar Zeilen C-Code hinter diesen 2 Zeilen R-Code.

Ziel 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]

Gehen

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: Dieser Code liest die gesamte Quelle in den Speicher ein. Verwenden Sie daher die Option regexp.FindReaderIndex, um im Stream zu suchen, damit die App kugelsicher ist.

CJam

CJam hat keinen regulären Ausdruck, daher musste ich in diesem einen anderen Ansatz verwenden:

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

Ich konvertiere zuerst alles 'in ", teile dann alles auf ", nehme jede alternative Zeichenfolge und filtere diese Liste schließlich nach Zeichenfolgen, die mit http://oder beginnen https://. Danach drucken Sie einfach jede gefilterte Zeichenfolge in eine neue Zeile.

Probieren Sie es mit dem Java-Interpreter wie

java -jar cjam-0.6.2.jar file.cjam

Dabei hat file.cjam den Inhalt des obigen Codes.

F #

Dieser Code könnte viel kürzer sein, aber ich würde so etwas schreiben, wenn ich jemals erwartet hätte, diesen Code wieder lesen oder verwenden zu müssen, damit er viele unnötige Typanmerkungen enthält. Es wird die Verwendung eines aktiven Muster- MatchValue demonstriert , um das Muster-Matching gegen den Standard-CLR-Typ Match zu ermöglichen

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)

Edit Ich habe getLinks zu einer eigenen Funktion gemacht