Stroustrup a récemment publié une série de messages qui réfutent les mythes populaires sur le C ++ . Le cinquième mythe est le suivant: «C ++ s’applique uniquement aux grands programmes compliqués». Pour le démystifier, il a écrit un simple programme C ++ téléchargeant une page Web et en extrayant des liens . C'est ici:

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

Montrons à Stroustrup ce qu'est un petit programme lisible .

1. Télécharger http://www.stroustrup.com/C++.html

2. Lister tous les liens:

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

Vous pouvez utiliser n'importe quelle langue, mais aucune bibliothèque tierce n'est autorisée.

Gagnant

La réponse C ++ a été remportée par un vote, mais elle repose sur une bibliothèque semi-tierce (interdite par les règles) et, avec un autre concurrent proche, Bash , sur un client HTTP piraté (cela ne fonctionnera pas avec HTTPS, gzip, redirections, etc.). Donc, Wolfram est un gagnant clair. Une autre solution qui se rapproche du point de vue de la taille et de la lisibilité est PowerShell (avec une amélioration par rapport aux commentaires), mais elle n’a pas suscité beaucoup d’attention. Les langages traditionnels ( Python , C # ) sont également très proches.

Wolfram

Cela ressemble à de la triche complète

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

Il suffit donc d'ajouter une analyse honnête sur le dessus

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

Le principal inconvénient est la nature délicate de boost :: asio, je suis sûr que cela peut être encore plus court avec une meilleure bibliothèque.

Pure Bash sous Linux / OS X (pas d'utilitaire externe)

Le logiciel client HTTP est notoirement gonflé. Nous ne voulons pas de ce genre de dépendances. Au lieu de cela, nous pouvons insérer les en-têtes appropriés dans un flux TCP et lire le résultat. Nul besoin d'appeler des utilitaires archaïques comme grep ou sed pour analyser le résultat.

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 - Je suppose que ça pourrait être plus lisible ...

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

Lame, mais fonctionne

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

"Pas de tiers" est une erreur

Je pense que l'hypothèse "pas de tierce partie" est une erreur. Et est une erreur spécifique qui afflige les développeurs C ++, car il est si difficile de créer du code réutilisable en C ++. Lorsque vous développez quelque chose que ce soit, même s'il s'agit d'un petit script, vous utiliserez toujours les morceaux de code réutilisables qui vous sont disponibles.

Le fait est que, dans des langages comme Perl, Python, Ruby (pour n'en nommer que quelques-uns), la réutilisation du code de quelqu'un d'autre est non seulement facile, mais permet également à la plupart des gens d'écrire du code la plupart du temps.

C ++, avec ses exigences ABI compatibles presque impossibles à maintenir, rend ce travail beaucoup plus difficile, vous vous retrouvez avec un projet comme Boost, qui est un immense dépôt de code et une très faible composabilité en dehors de celui-ci.

Un exemple de CPAN

Juste pour le plaisir, voici un exemple basé sur CPAN, avec une analyse syntaxique correcte du html, au lieu d’ essayer d’utiliser regex pour analyser 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");

Shell UNIX

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

Trouve également un ftp://lien :)

Une autre façon, sans compter sur la ://syntaxe:

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

Ce code peut être utilisé comme style utilisateur pour afficher uniquement les liens absolus sur une page dans une liste non formatée. Il risque de ne pas fonctionner correctement si votre navigateur impose une taille de police minimale.

Cela fonctionne correctement avec http://www.stroustrup.com/C++.html(note !importantsur background). Pour pouvoir travailler sur d'autres pages avec plus de styles, il doit être étendu (réinitialiser davantage de propriétés, marquer les propriétés comme importantes, etc.).

Version alternative qui inclut des liens relatifs sauf les liens intrapage commençant par des hachages (elle repose malheureusement sur un lien absolu codé en dur):

* {
  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

Recherche de texte pour toutes les URL entièrement qualifiées (y compris JavaScript, CSS, etc.):

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

Ou pour obtenir des liens dans les balises d'ancrage uniquement (inclut les URL relatives):

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

Des versions plus courtes des commentaires:

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

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

ré

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

Rubis

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

Haskell

Quelques problèmes avec "\w"dans 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

Autant que je sache, la plupart des installations PHP modernes intègrent un traitement DOM. En voici donc une qui traverse les ancres à l'intérieur du code 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;
    }
}

La boucle interne pourrait être réduite à:

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

Bien que je dois admettre que cela ne fonctionne pas s'il y a plus d'un lien sur une ligne.

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

Sensationnel

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

SQL (SQL Anywhere 16)

Définir une procédure stockée pour récupérer la page Web

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

Produire le jeu de résultats en utilisant une seule requête

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;

Limitations: Cela produit jusqu'à 256 liens. Si plus de liens existent, alors remplacez le 256 par une valeur appropriée.

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

... bien que R soit écrit principalement en C ... donc probablement quelques lignes de code C derrière ces 2 lignes de code R.

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

Aller

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: ce code lit l'intégralité de la source en mémoire, pensez donc à utiliser la regexp.FindReaderIndexrecherche en flux pour rendre l'application à l'épreuve des balles.

CJam

CJam n'a pas de regex et j'ai donc dû utiliser une approche différente dans celle-ci:

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

Je convertis d'abord tout 'en ", puis je divise tout ", je prends chaque chaîne alternative et enfin filtre cette liste pour les chaînes commençant par http://ou https://. Ensuite, imprimez simplement chaque chaîne filtrée sur une nouvelle ligne.

Essayez-le en utilisant l' interpréteur Java comme

java -jar cjam-0.6.2.jar file.cjam

où fichier.cjam a le contenu du code ci-dessus.

F#

Ce code pourrait être beaucoup plus court, mais j'écrirais quelque chose comme ceci si je m'attendais à devoir lire ou utiliser à nouveau ce code afin qu'il contienne de nombreuses annotations de type inutiles. Il illustre l'utilisation d'un modèle actif MatchValue pour permettre la correspondance de modèle avec le type de CLR standard Match

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 j'ai fait à getLinks sa propre fonction