Stroustrup ha publicado recientemente una serie de publicaciones que desacreditan mitos populares sobre C ++ . El quinto mito es: "C ++ es solo para programas grandes y complicados". Para desacreditarlo, escribió un sencillo programa en C ++ que descarga una página web y extrae enlaces de ella . Aquí 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 a mostrarle a Stroustrup qué es un programa pequeño y legible .

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

2. Listar todos los enlaces:

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

Puede usar cualquier idioma, pero no se permiten bibliotecas de terceros.

Ganador

La respuesta de C ++ ganada por votos, pero se basa en una biblioteca de terceros (que no está permitida por las reglas) y, junto con otro competidor cercano, Bash , se basa en un cliente HTTP pirateado (no funcionará con HTTPS, gzip, redirecciones, etc.). Entonces Wolfram es un claro ganador. Otra solución que se acerca en términos de tamaño y legibilidad es PowerShell (con la mejora de los comentarios), pero no ha recibido mucha atención. Los lenguajes convencionales ( Python , C # ) también se acercaron bastante.

Wolfram

Esto se siente como una trampa completa

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

Así que solo agrega un análisis honesto en la parte superior

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

La principal deficiencia es la naturaleza incómoda de boost :: asio, estoy seguro de que puede ser aún más corto con una mejor biblioteca.

Pure Bash en Linux / OS X (sin utilidades externas)

El software de cliente HTTP está notoriamente inflado. No queremos ese tipo de dependencias. En su lugar, podemos empujar los encabezados apropiados hacia abajo en una secuencia TCP y leer el resultado. No es necesario llamar a servicios arcaicos como grep o sed para analizar el 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: supongo que podría ser más legible ...

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

Cojo, pero 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);
    }
}

"Ningún tercero" es una falacia

Creo que la suposición de "no terceros" es una falacia. Y es una falacia específica que afecta a los desarrolladores de C ++, ya que es muy difícil crear código reutilizable en C ++. Cuando desarrolle algo, incluso si se trata de un script pequeño, siempre utilizará las piezas de código reutilizables disponibles.

La cuestión es que, en lenguajes como Perl, Python, Ruby (por nombrar algunos), reutilizar el código de otra persona no solo es fácil, sino que es cómo la mayoría de las personas realmente escriben código la mayor parte del tiempo.

C ++, con sus requisitos ABI casi imposibles de mantener, hace que sea un trabajo mucho más difícil, terminas con un proyecto como Boost, que es un depósito monstruoso de código y muy poca compostura fuera de él.

Un ejemplo de CPAN

Solo por diversión, aquí va un ejemplo basado en CPAN, con el análisis adecuado del html, en lugar de tratar de usar regex para analizar 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 de UNIX

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

También encuentra un ftp://enlace :)

Otra forma, sin depender de la ://sintaxis:

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

Este código puede usarse como un estilo de usuario para mostrar solo enlaces absolutos en una página en una lista sin formato. Es posible que no funcione correctamente si su navegador exige un tamaño de fuente mínimo.

Funciona correctamente con http://www.stroustrup.com/C++.html(nota !importantsobre background). Para trabajar en otras páginas con más estilos, debe ampliarse (restablecer más propiedades, marcar propiedades como importantes, etc.).

Versión alternativa que incluye enlaces relativos, excepto los enlaces intrapágina que comienzan con hashes (lamentablemente, se basa en un enlace 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]);

Potencia Shell

Búsqueda de texto para todas las URL totalmente calificadas (incluidos JavaScript, CSS, etc.):

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

O para obtener enlaces solo en etiquetas de anclaje (incluye URL relativas):

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

Versiones más cortas de los comentarios:

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

Rubí

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

Haskell

Algunos problemas con "\w"en 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

Por lo que puedo decir, la mayoría de las instalaciones PHP modernas vienen con procesamiento DOM, así que aquí hay una que realmente atraviesa los anclajes dentro del 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;
    }
}

El circuito interno podría acortarse a:

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

Aunque tengo que admitir que esto no funciona si hay más de un enlace en una línea.

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

Maravilloso

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

SQL (SQL en cualquier lugar 16)

Definir un procedimiento almacenado para recuperar la página web.

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

Produzca el conjunto de resultados usando una sola 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;

Limitaciones: Esto produce hasta 256 enlaces. Si existen más enlaces, suba el 256 a un valor apropiado.

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

... aunque R está escrito principalmente en C ... así que probablemente unas pocas líneas de código C detrás de esas 2 líneas de código R.

C objetivo

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

PD: este código lee toda la fuente en la memoria, así que considera usarlo regexp.FindReaderIndexpara buscar en stream, eso hará que la aplicación sea a prueba de balas.

CJam

CJam no tiene expresiones regulares, así que tuve que usar un enfoque diferente en este:

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

Primero convierto todo 'a ", luego me divido en todos ", tomo cada cadena alternativa y finalmente filtro esa lista para las cadenas que comienzan con http://o https://. Después de eso, simplemente imprima cada cadena filtrada en una nueva línea.

Pruébelo utilizando el intérprete de Java como

java -jar cjam-0.6.2.jar file.cjam

donde file.cjam tiene el contenido del código anterior.

F#

Este código podría ser mucho más corto, pero escribiría algo como esto si alguna vez esperaba tener que leer o usar este código nuevamente, por lo que tiene muchas anotaciones de tipo innecesarias. Demuestra el uso de un patrón MatchValue activo para permitir la coincidencia de patrones con el tipo estándar CLR 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 hice que getLinks tenga su propia función