Stroustrup ha recentemente pubblicato una serie di post che sfatano i miti popolari sul C ++ . Il quinto mito è: "C ++ è solo per programmi grandi, complicati". Per sfatarlo, scrisse un semplice programma C ++ scaricando una pagina Web ed estraendo collegamenti da essa . Ecco qui:

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

Mostriamo a Stroustrup che cos'è in realtà un programma piccolo e leggibile .

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

2. Elenca tutti i collegamenti:

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

È possibile utilizzare qualsiasi lingua, ma non sono consentite librerie di terze parti.

Vincitore

Risposta C ++ vinta dai voti, ma si basa su una libreria di terze parti (che non è consentita dalle regole) e, insieme a un altro concorrente stretto Bash , si affida a un client HTTP hackerato insieme (non funzionerà con HTTPS, gzip, reindirizzamenti ecc.). Quindi Wolfram è un chiaro vincitore. Un'altra soluzione che si avvicina in termini di dimensioni e leggibilità è PowerShell (con miglioramento dai commenti), ma non ha ricevuto molta attenzione. Anche le lingue mainstream ( Python , C # ) si sono avvicinate abbastanza.

Wolfram

Sembra un imbroglio completo

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

Quindi aggiungi solo un po 'di analisi onesta in cima

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

Il principale difetto è la natura scomoda di boost :: asio, sono sicuro che può essere ancora più breve con una libreria migliore.

Pure Bash su Linux / OS X (nessuna utility esterna)

Il software client HTTP è notoriamente gonfio. Non vogliamo questo tipo di dipendenze. Possiamo invece spingere le intestazioni appropriate in un flusso TCP e leggere il risultato. Non è necessario chiamare utilità arcaiche come grep o sed per analizzare il risultato.

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 - Suppongo che potrebbe essere più leggibile ...

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, ma funziona

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

"No di terze parti" è un errore

Penso che il presupposto "no di terze parti" sia un errore. Ed è un errore specifico che affligge gli sviluppatori C ++, poiché è così difficile rendere il codice riutilizzabile in C ++. Quando stai sviluppando qualcosa, anche se si tratta di un piccolo script, farai sempre uso di tutti i pezzi di codice riutilizzabili disponibili.

Il fatto è che in lingue come Perl, Python, Ruby (solo per citarne alcuni), riutilizzare il codice di qualcun altro non è solo facile, ma è come la maggior parte delle persone scrive il codice la maggior parte delle volte.

Il C ++, con i suoi requisiti ABI compatibili quasi impossibili da mantenere, rende un lavoro molto più difficile, si finisce con un progetto come Boost, che è un mostruoso repository di codice e pochissima componibilità al di fuori di esso.

Un esempio di CPAN

Solo per divertimento, ecco un esempio basato su CPAN, con una corretta analisi dell'html, invece di provare a usare regex per analizzare l'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*://.*'

Trova anche un ftp://link :)

Un altro modo, senza fare affidamento sulla ://sintassi:

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

Questo codice può essere utilizzato come stile utente per visualizzare solo collegamenti assoluti su una pagina in un elenco non formattato. Potrebbe non funzionare correttamente se il tuo browser applica dimensioni minime del carattere.

Funziona correttamente con http://www.stroustrup.com/C++.html(nota !importantsu background). Per funzionare su altre pagine con più stili, è necessario estenderlo (ripristinare più proprietà, contrassegnare le proprietà come importanti ecc.).

Versione alternativa che include collegamenti relativi tranne i collegamenti intrapage che iniziano con gli hash (purtroppo si basa su un collegamento assoluto codificato):

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

Ricerca di testo per tutti gli URL completi (inclusi JavaScript, CSS, ecc.):

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

Oppure per ottenere collegamenti solo nei tag di ancoraggio (include URL relativi):

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

Versioni più brevi dai commenti:

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

Rubino

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

Haskell

Alcuni problemi con "\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

Per quanto ne so, la maggior parte delle moderne installazioni PHP sono dotate di elaborazione DOM, quindi eccone una che attraversa effettivamente le ancore all'interno dell'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;
    }
}

Il circuito interno potrebbe essere abbreviato in:

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

Anche se devo ammettere che questo non funziona se c'è più di un collegamento su una linea.

Giava

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)

Definire una procedura memorizzata per recuperare la pagina Web

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

Produrre il set di risultati utilizzando una singola query

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;

Limitazioni: produce fino a 256 collegamenti. Se esistono più collegamenti, aumentare il 256 su un valore appropriato.

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

... sebbene R sia scritto principalmente in C ... quindi probabilmente alcune righe di codice C dietro quelle 2 righe di codice R.

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

Partire

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 questo codice legge l'intera fonte in memoria, quindi considera l'utilizzo regexp.FindReaderIndexdi una ricerca in streaming, che renderà l'app antiproiettile.

CJam

CJam non ha regex quindi ho dovuto usare un approccio diverso in questo:

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

Per prima cosa converto tutto 'in ", quindi divido tutto ", prendo ogni stringa alternativa e infine filtra l'elenco per le stringhe che iniziano con http://o https://. Successivamente, stampa semplicemente ogni stringa filtrata su una nuova riga.

Provalo usando l' interprete Java come

java -jar cjam-0.6.2.jar file.cjam

dove file.cjam ha i contenuti del codice sopra.

F #

Questo codice potrebbe essere molto più breve, ma scriverei qualcosa del genere se mi aspettassi di leggere o utilizzare nuovamente questo codice in modo che abbia molte annotazioni di tipo non necessarie. Dimostra l'uso di un patternValue di pattern attivo per abilitare il pattern-matching rispetto al tipo 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)

Modifica Ho fatto getLink la sua funzione