Stroustrup kısa süre önce C ++ ile ilgili popüler mitleri gözden düşüren bir dizi yazı yayınladı . Beşinci mit: “C ++ sadece büyük, karmaşık, programlar içindir”. Bunu boşaltmak için, bir web sayfasını indiren ve ondan bağlantılar çıkaran basit bir C ++ programı yazdı . İşte burada:

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

Stroustrup'a gerçekte küçük ve okunabilir bir programın ne olduğunu gösterelim .

1. İndir http://www.stroustrup.com/C++.html

2. Tüm bağlantıları listele:

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

Herhangi bir dili kullanabilirsiniz, ancak üçüncü taraf kütüphanelerine izin verilmez.

kazanan

Oyların kazandığı C ++ cevabı , ancak kurallara uymayan yarı-üçüncü parti bir kütüphaneye dayanıyor ve başka bir yakın rakip Bash ile birlikte , saldırıya uğramış bir HTTP istemcisine güveniyor (HTTPS ile çalışmaz, gzip, yönlendirmeler vs.) Öyleyse Wolfram açık bir kazanan. Boyut ve okunabilirlik açısından yaklaşan bir başka çözüm de PowerShell'dir (yorumların iyileştirilmesiyle birlikte), ancak fazla dikkat çekmedi. Ana dilleri ( Python , C # ) da oldukça yaklaştı.

volfram

Bu tam hile gibi geliyor

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

Bu yüzden sadece üstüne biraz dürüst ayrıştırma ekleyin

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

Asıl eksiklik, boost :: asio'nun garip doğasıdır, daha iyi bir kütüphane ile daha da kısa olabileceğinden eminim.

Linux / OS X'te Saf Bash (harici yardımcı program yoktur)

HTTP istemci yazılımı bilinen bir şekilde şişirilir. Bu tür bağımlılıkları istemiyoruz. Bunun yerine uygun başlıkları bir TCP akışından aşağı indirebilir ve sonucu okuyabiliriz. Sonucu ayrıştırmak için grep veya sed gibi arkaik programları aramanıza gerek yok.

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 - Sanırım daha okunaklı olabilir ...

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, ama çalışıyor

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

"Üçüncü taraf yok" yanlış bir şey

"Üçüncü taraf yok" varsayımının bir yanlışlık olduğunu düşünüyorum. C ++ geliştiricilerini etkileyen belirli bir yanılgıdır, çünkü C ++ 'ta yeniden kullanılabilir kod yapmak çok zordur. Hiç bir şey geliştirirken, küçük bir senaryo olsa bile, kullanabileceğiniz kodlardan her zaman yararlanabileceksiniz.

Mesele şu ki, Perl, Python, Ruby gibi dillerde (bir kaç isim), başkasının kodunu tekrar kullanmak sadece kolay değil, aynı zamanda çoğu insanın çoğu zaman nasıl kod yazdığıdır.

C ++, neredeyse imkansız bakımı-uyumlu-ABI gereklilikleriyle, çok daha zorlu bir iş yapıyor, kodun canavarca bir deposu ve bunun dışında çok az bir bestecilik olan Boost gibi bir projeyle sonuçlanıyor.

Bir CPAN örneği

Sadece eğlenmek için, burada html'yi ayrıştırmak için regex kullanmaya çalışmak yerine, html'nin uygun şekilde ayrıştırılmasıyla CPAN tabanlı bir örnek verilecek.

#!/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 kabuğu

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

Ayrıca bir ftp://link bulur :)

Başka bir yol, ://sözdizimine güvenmeden :

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

Bu kod, biçimlendirilmemiş bir listedeki bir sayfada yalnızca mutlak bağlantıları görüntülemek için bir kullanıcı stili olarak kullanılabilir. Tarayıcınız minimum yazı tipi boyutunu zorlarsa doğru çalışmayabilir.

İle doğru çalışır http://www.stroustrup.com/C++.html(not !importantüzerine background). Daha fazla stil içeren diğer sayfalarda çalışmak için genişletilmesi gerekir (daha fazla özelliği sıfırlayın, özellikleri önemli olarak işaretleyin vb.).

Karmalarla başlayan intrapage bağlantılar dışında göreceli bağlantılar içeren alternatif sürüm (ne yazık ki sabit kodlanmış mutlak bir bağlantıya dayanır):

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

Güç kalkanı

Tam nitelikli URL’lerin (JavaScript, CSS, vb. Dahil) metin araması :

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

Veya yalnızca bağlantı etiketlerinde bağlantı almak için (göreli URL’leri içerir):

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

Yorumlardan daha kısa sürümler:

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

Yakut

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

Haskell

"\w"Text.Regex.Posix’de bazı sıkıntılar

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

Söyleyebileceğim kadarıyla, modern PHP kurulumlarının çoğu DOM işlemesi ile birlikte geliyor, işte aslında HTML'nin içindeki çapaları geçen bir tane:

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

İç döngü şuna kısaltılabilir:

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

Unix Kabuğu

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

İtiraf etmeliyim ki, bir hatta birden fazla bağlantı varsa işe yaramaz.

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

harika

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

SQL (SQL Her Yerde 16)

Web sayfasını almak için saklı bir prosedür tanımlayın

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

Tek bir sorgu kullanarak sonuç kümesini üret

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;

Sınırlamalar: Bu 256'ya kadar bağlantı üretir. Daha fazla bağlantı varsa, 256'yı uygun bir değere yükseltin.

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

... R esas olarak C dilinde yazılsa da, muhtemelen bu 2 satır R kodunun arkasındaki birkaç satır C kodu.

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]

Git

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 bu kod kaynağın tamamını belleğe okur, bu nedenle regexp.FindReaderIndexuygulamayı kurşun geçirmez hale getirecek akışta aramayı kullanmayı düşünün .

CJam

CJam'ın regex'i olmadığından, bu konuda farklı bir yaklaşım kullanmak zorunda kaldım:

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

Ben her şeyden önce dönüştürmek 'için "o zaman tümü üzerinde bölünmüş, "her alternatif dize almak ve sonra nihayet başlayarak dizeleri için bu listeye filtre http://veya https://. Bundan sonra, filtrelenen her dizeyi yeni bir satıra yazdırmanız yeterlidir.

Gibi Java tercümanı kullanarak deneyin

java -jar cjam-0.6.2.jar file.cjam

Burada file.cjam yukarıdaki kodun içeriğine sahiptir.

F #

Bu kod çok daha kısa olabilirdi, ancak bu kodu tekrar okumak ya da kullanmak zorunda kalırsam, bu yüzden pek çok gereksiz tip ek açıklamasına sahip olsaydım, bunun gibi bir şey yazardım. Bu aktif bir desen kullanımını gösterir MatchValue standart CLR tipi karşı desen eşleştirme etkinleştirmek için 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 GetLinks'i kendi işlevi yaptım