Stroustrup gần đây đã đăng một loạt các bài đăng vạch trần những huyền thoại phổ biến về C ++ . Huyền thoại thứ năm là: Chỉ C ++ dành cho các chương trình lớn, phức tạp, chỉ có. Để gỡ lỗi, anh ta đã viết một chương trình C ++ đơn giản tải xuống một trang web và trích xuất các liên kết từ nó . Đây là:

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

Hãy cho Stroustrup biết chương trình nhỏ và dễ đọc thực sự là gì.

1. Tải xuống http://www.stroustrup.com/C++.html

2. Liệt kê tất cả các liên kết:

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

Bạn có thể sử dụng bất kỳ ngôn ngữ nào, nhưng không cho phép thư viện của bên thứ ba.

Người chiến thắng

Câu trả lời của C ++ đã giành được bằng phiếu bầu, nhưng nó dựa vào thư viện của bên thứ ba (không được phép theo quy tắc) và cùng với một đối thủ cạnh tranh thân thiết khác là Bash , dựa vào ứng dụng khách HTTP bị hack (nó sẽ không hoạt động với HTTPS, gzip, chuyển hướng, v.v.). Vì vậy, Wolfram là một người chiến thắng rõ ràng. Một giải pháp khác gần gũi về kích thước và khả năng đọc là PowerShell (với sự cải thiện từ các bình luận), nhưng nó đã không nhận được nhiều sự chú ý. Các ngôn ngữ chính ( Python , C # ) cũng đến khá gần.

Sói

Cảm giác như gian lận hoàn toàn

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

Vì vậy, chỉ cần thêm một số phân tích trung thực trên đầu trang

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

Thiếu sót chính là bản chất khó xử của boost :: asio, tôi chắc chắn rằng nó có thể còn ngắn hơn với một thư viện tốt hơn.

Pure Bash trên Linux / OS X (không có tiện ích bên ngoài)

Phần mềm máy khách HTTP nổi tiếng là cồng kềnh. Chúng tôi không muốn những loại phụ thuộc. Thay vào đó, chúng ta có thể đẩy các tiêu đề thích hợp xuống luồng TCP và đọc kết quả. Không cần phải gọi các tiện ích cổ xưa như grep hoặc sed để phân tích kết quả.

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 - Tôi cho rằng nó có thể dễ đọc hơn ...

Con trăn 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, nhưng làm việc

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

"Không có bên thứ ba" là một ngụy biện

Tôi nghĩ rằng giả định "không có bên thứ ba" là sai lầm. Và là một sai lầm cụ thể ảnh hưởng đến các nhà phát triển C ++, vì rất khó để tạo mã có thể sử dụng lại trong C ++. Khi bạn đang phát triển bất cứ điều gì, ngay cả khi đó là một tập lệnh nhỏ, bạn sẽ luôn sử dụng bất kỳ đoạn mã có thể tái sử dụng nào có sẵn cho bạn.

Vấn đề là, trong các ngôn ngữ như Perl, Python, Ruby (để đặt tên cho một số ít), việc sử dụng lại mã của người khác không chỉ dễ dàng, mà đó là cách mà hầu hết mọi người thực sự viết mã hầu hết thời gian.

C ++, với các yêu cầu ABI gần như không thể duy trì tương thích của nó làm cho công việc khó khăn hơn nhiều, bạn kết thúc với một dự án như Boost, một kho lưu trữ mã khổng lồ và rất ít khả năng kết hợp bên ngoài nó.

Một ví dụ CPAN

Để giải trí, đây là một ví dụ dựa trên CPAN, với phân tích cú pháp html đúng, thay vì cố gắng sử dụng regex để phân tích cú pháp 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");

Vỏ UNIX

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

Cũng tìm thấy một ftp://liên kết :)

Một cách khác, không dựa vào ://cú pháp:

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

Mã này có thể được sử dụng làm kiểu người dùng để chỉ hiển thị các liên kết tuyệt đối trên một trang trong danh sách không được định dạng. Nó có thể không hoạt động chính xác nếu trình duyệt của bạn thực thi kích thước phông chữ tối thiểu.

Nó hoạt động chính xác với http://www.stroustrup.com/C++.html(lưu ý !importanttrên background). Để làm việc trên các trang khác có nhiều kiểu hơn, nó phải được mở rộng (đặt lại nhiều thuộc tính, đánh dấu các thuộc tính là quan trọng, v.v.).

Phiên bản thay thế bao gồm các liên kết tương đối ngoại trừ các liên kết intrapage bắt đầu bằng băm (không may, nó phụ thuộc vào một liên kết tuyệt đối được mã hóa cứng, không may):

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

Tìm kiếm văn bản cho tất cả các URL đủ điều kiện (bao gồm JavaScript, CSS, v.v.):

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

Hoặc để nhận liên kết chỉ trong các thẻ neo (bao gồm các URL tương đối):

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

Các phiên bản ngắn hơn từ ý kiến:

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

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

CƯỜI MỞ MIỆNG

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

Hồng ngọc

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

Haskell

Một số rắc rối với "\w"trong 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

Theo như tôi có thể nói, hầu hết các bản cài đặt PHP hiện đại đều đi kèm với xử lý DOM, vì vậy đây là một bản cài đặt thực sự vượt qua các neo trong 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;
    }
}

Vòng lặp bên trong có thể được rút ngắn thành:

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

Vỏ Unix

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

Mặc dù tôi phải thừa nhận điều này không hoạt động nếu có nhiều hơn một liên kết trên một dòng.

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 ở mọi nơi 16)

Xác định thủ tục được lưu trữ để tìm nạp trang web

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

Tạo tập kết quả bằng một truy vấn duy nhất

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;

Hạn chế: Điều này tạo ra tới 256 liên kết. Nếu có nhiều liên kết tồn tại, sau đó tăng 256 đến một giá trị thích hợp.

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

... mặc dù R được viết chủ yếu bằng C ... nên có lẽ một vài dòng mã C đằng sau 2 dòng mã R đó.

Mục tiêu-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]

Đi

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 mã này đọc toàn bộ nguồn vào bộ nhớ, vì vậy hãy cân nhắc sử dụng regexp.FindReaderIndexđể tìm kiếm trong luồng, điều đó sẽ giúp ứng dụng chống đạn.

Camam

CJam không có regex nên tôi phải sử dụng một cách tiếp cận khác trong cách này:

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

Trước tiên tôi chuyển đổi tất cả 'thành ", sau đó tôi tách tất cả ", lấy mọi chuỗi thay thế và cuối cùng là lọc danh sách đó cho các chuỗi bắt đầu bằng http://hoặc https://. Sau đó, chỉ cần in từng chuỗi được lọc trên một dòng mới.

Hãy thử nó bằng trình thông dịch Java như

java -jar cjam-0.6.2.jar file.cjam

trong đó file.cjam có nội dung của đoạn mã trên.

ĐỤ#

Mã này có thể ngắn hơn nhiều nhưng tôi sẽ viết một cái gì đó như thế này nếu tôi dự kiến ​​sẽ phải đọc hoặc sử dụng lại mã này để nó có nhiều chú thích loại không cần thiết. Nó thể hiện việc sử dụng một mô hình hoạt động MatchValue để cho phép mô hình khớp so với tiêu chuẩn loại CLR trận đấu

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)

Chỉnh sửa Tôi đã tạo getLinks chức năng riêng của mình