Stroustrup publicou recentemente uma série de posts desmistificando mitos populares sobre C ++ . O quinto mito é: "C ++ é somente para programas grandes e complicados". Para desmascará-lo, ele escreveu um programa C ++ simples, baixando uma página da Web e extraindo links dela . Aqui está:

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

Vamos mostrar ao Stroustrup o que é um programa pequeno e legível .

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

2. Listar todos os links:

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

Você pode usar qualquer idioma, mas nenhuma biblioteca de terceiros é permitida.

Vencedora

A resposta C ++ ganhou por votos, mas depende de uma biblioteca de terceiros (o que não é permitido por regras) e, junto com outro concorrente próximo Bash , conta com um cliente HTTP invadido (que não funcionará com HTTPS, gzip, redireciona etc.). Então Wolfram é um vencedor claro. Outra solução que se aproxima em termos de tamanho e legibilidade é o PowerShell (com melhorias nos comentários), mas não recebeu muita atenção. Linguagens mainstream ( Python , C # ) também chegaram bem perto.

Volfrâmio

Parece trapaça completa

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

Então, basta adicionar algumas análises honestas no topo

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

A principal falha é a natureza incômoda do boost :: asio, tenho certeza que pode ser ainda mais curta com uma biblioteca melhor.

Pure Bash no Linux / OS X (sem utilitários externos)

O software cliente HTTP é notoriamente inchado. Não queremos esse tipo de dependência. Em vez disso, podemos enviar os cabeçalhos apropriados para um fluxo TCP e ler o resultado. Não é necessário chamar utilitários arcaicos como grep ou sed para analisar o resultado.

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 - Suponho que poderia ser mais legível ...

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

Manco, mas funciona

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

"Nenhum terceiro" é uma falácia

Eu acho que a suposição de "não de terceiros" é uma falácia. E é uma falácia específica que afeta os desenvolvedores de C ++, pois é muito difícil criar código reutilizável em C ++. Quando você estiver desenvolvendo alguma coisa, mesmo que seja um script pequeno, sempre usará qualquer parte do código reutilizável disponível.

O problema é que, em linguagens como Perl, Python, Ruby (para citar alguns), reutilizar o código de outra pessoa não é apenas fácil, mas é como a maioria das pessoas realmente escreve código na maioria das vezes.

O C ++, com seus requisitos ABI quase impossíveis de manter, torna esse trabalho muito mais difícil; você acaba com um projeto como o Boost, que é um repositório monstruoso de código e com pouca composição fora dele.

Um exemplo de CPAN

Apenas por diversão, aqui está um exemplo baseado em CPAN, com análise adequada do html, em vez de tentar usar o regex para analisar o 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*://.*'

Também encontra um ftp://link :)

Outra maneira, sem depender da ://sintaxe:

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

Esse código pode ser usado como um estilo de usuário para exibir apenas links absolutos em uma página em uma lista não formatada. Pode não funcionar corretamente se o seu navegador aplicar o tamanho mínimo da fonte.

Funciona corretamente com http://www.stroustrup.com/C++.html(note !importanton background). Para trabalhar em outras páginas com mais estilos, ele deve ser estendido (redefinir mais propriedades, marcar propriedades como importantes etc.).

Versão alternativa que inclui links relativos, exceto os links entre páginas que começam com hashes (infelizmente, depende de um link absoluto codificado):

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

Pesquisa de texto para todos os URLs totalmente qualificados (incluindo JavaScript, CSS etc.):

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

Ou para obter links apenas em tags âncora (inclui URLs relativos):

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

Versões mais curtas dos comentários:

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

Rubi

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

Haskell

Alguns problemas "\w"no 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

Tanto quanto posso dizer, a maioria das instalações PHP modernas vem com processamento DOM, então aqui está uma que realmente atravessa as âncoras dentro do 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;
    }
}

O loop interno pode ser reduzido para:

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

Shell Unix

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

Embora eu tenha que admitir que isso não funciona se houver mais de um link em uma linha.

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)

Definir um procedimento armazenado para buscar a página da web

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

Produza o conjunto de resultados usando uma única consulta

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;

Limitações: Isso produz até 256 links. Se existirem mais links, aumente os 256 para um valor apropriado.

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

... embora R seja escrito principalmente em C ... provavelmente algumas linhas de código C por trás dessas 2 linhas de código R.

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

Ir

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 esse código lê toda a fonte na memória, então considere usar regexp.FindReaderIndexpara pesquisar no fluxo, para tornar o aplicativo à prova de balas.

CJam

O CJam não possui regex, então tive que usar uma abordagem diferente nesta:

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

Primeiro converto tudo 'para ", depois divido sobre tudo ", pego todas as strings alternativas e, finalmente, filtre essa lista por strings começando com http://or https://. Depois disso, basta imprimir cada sequência filtrada em uma nova linha.

Experimente usando o interpretador Java como

java -jar cjam-0.6.2.jar file.cjam

onde file.cjam possui o conteúdo do código acima.

F #

Esse código pode ser muito mais curto, mas eu escreveria algo assim se esperasse ter que ler ou usar esse código novamente, para que ele tenha muitas anotações de tipo desnecessárias. Demonstra o uso de um padrão ativo MatchValue para habilitar a correspondência de padrões com o tipo CLR padrão 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)

Editar Eu criei a função getLinks