ස්ට්‍රෝස්ට්‍රප් විසින් මිථ්‍යාව ඉවත් කිරීම “සී ++ විශාල, සංකීර්ණ, වැඩසටහන් සඳහා පමණි”


160

ස්ට්‍රෝස්ට්‍රප් මෑතකදී සී ++ පිළිබඳ ජනප්‍රිය මිථ්‍යාවන් ඉවත් කරමින් පළ කරන ලද ලිපි මාලාවක් පළ කළේය . පස්වන මිථ්‍යාව නම්: “C ++ විශාල, සංකීර්ණ, වැඩසටහන් සඳහා පමණි”. එය ඉවත් කිරීම සඳහා ඔහු සරල C ++ වැඩසටහනක් වෙබ් පිටුවක් බාගත කර එයින් සබැඳි උපුටා ගත්තේය . මේ තියෙන්නේ:

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

කුඩා හා කියවිය හැකි වැඩසටහන කුමක්දැයි ස්ට්‍රෝස්ට්‍රප් පෙන්වමු .

  1. බාගත http://www.stroustrup.com/C++.html
  2. සියලුම සබැඳි ලැයිස්තුගත කරන්න:

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

ඔබට ඕනෑම භාෂාවක් භාවිතා කළ හැකිය, නමුත් තෙවන පාර්ශවීය පුස්තකාලවලට අවසර නැත.

ජයග්රාහකයා

C ++ පිළිතුර ඡන්දයෙන් දිනා ගත් නමුත් එය රඳා පවතින්නේ අර්ධ තෙවන පාර්ශවීය පුස්තකාලයක් මත ය (එය නීති රීති වලට ඉඩ නොදේ), සහ තවත් සමීප තරඟකරුවෙකු වන බාෂ් සමඟ එක්ව හැක් කරන ලද HTTP සේවාදායකයා මත රඳා පවතී (එය HTTPS සමඟ ක්‍රියා නොකරනු ඇත, gzip, යළි-යොමුවීම් ආදිය). එබැවින් වුල්ෆ්රාම් පැහැදිලි ජයග්රාහකයෙකි. ප්‍රමාණය හා කියවීමේ හැකියාව අනුව සමීප වන තවත් විසඳුමක් වන්නේ පවර්ෂෙල් (අදහස් වලින් වැඩි දියුණු වීමක් සහිතව), නමුත් එයට වැඩි අවධානයක් ලැබී නැත. ප්‍රධාන ධාරාවේ භාෂා ( පයිතන් , සී # ) ද ඉතා සමීප විය.


43
එක් එක් කෙනාට, මාව වඩාත් නරක ලෙස හැඳින්වේ. OP හි ඉලක්කය ස්ට්‍රෝස්ට්‍රප් වැරදියි කියා කෙසේ හෝ ඔප්පු කිරීම නොවේ නම්, මම ඔබේ තක්සේරුව සමඟ එකඟ වෙමි. නමුත් ප්‍රශ්නයේ මුලික අංගය වන්නේ "ඔබේ ප්‍රියතම භාෂාවට" මෙම C ++ පේළි 50 ට වඩා අඩු කේත පේළි වලින් කළ හැක්කේ කෙසේද යන්න පෙන්වීමයි. ගැටලුව වන්නේ උදාහරණ කිසිවක් එකම දේ නොකිරීමයි. විශේෂයෙන්, කිසිදු පිළිතුරක් කිසිදු දෝෂ පරීක්ෂාවක් සිදු නොකරයි, පිළිතුරු කිසිවක් නැවත භාවිතා කළ හැකි කාර්යයන් සපයන්නේ නැත, බොහෝ පිළිතුරු සම්පූර්ණ වැඩසටහනක් සපයන්නේ නැත. Stroustrup උදාහරණය ඒ සියල්ල සපයයි.
ඩන්ක්

19
කනගාටුදායක කාරණය නම් ඔහුගේ වෙබ් පිටුව වලංගු නොවන UTF-8 ය . ඔහුගේ සේවාදායක වෙළඳ දැන්වීම් නොතකා දැන් මම ඒ වටා වැඩ කළ යුතුයි Content-Type: text/html; charset=UTF-8... මම ඔහුට ඊමේල් කරන්නෙමි.
කෝන්ස්ටාක්ස්

27
Unk ඩන්ක් අනෙක් උදාහරණ නැවත භාවිතා කළ හැකි කාර්යයන් සපයන්නේ ඒවා එකී රේඛාවකින් එම ශ්‍රිතවල සම්පූර්ණ ක්‍රියාකාරිත්වය ඉටු කරන නිසා වන අතර සමස්ත ශ්‍රිතයක් තනිවම සිදු කිරීම තේරුමක් නැති අතර C ++ උදාහරණය කිසිදු දෝෂ පරීක්ෂාවක් සිදු නොකරයි. එය බොහෝ දුරට සමාන ආකාරයකින් හසුරුවනු නොලබන අතර “සම්පූර්ණ වැඩසටහන” යන වාක්‍ය ඛණ්ඩය පාහේ අර්ථ විරහිත ය.
ජේසන්

16
"ඔබට ඕනෑම භාෂාවක් භාවිතා කළ හැකිය. නමුත් තෙවන පාර්ශවීය පුස්තකාලවලට අවසර නැත." මම හිතන්නේ නැහැ සලකා සාධාරණ අවශ්යතාව එකක් කියලා boost/asioඉඩක් දක්වා භාවිතා වේ තෙවන පාර්ශවීය පුස්තකාලය. මා අදහස් කළේ එහි සම්මත පුස්තකාලයේ කොටසක් ලෙස url / tcp ලබා ගැනීම ඇතුළත් නොවන භාෂා තරඟ කරන්නේ කෙසේද?
මහා වුල්ෆ්

Answers:


116

වුල්ෆ්රාම්

මෙය සම්පූර්ණ වංචාවක් ලෙස හැඟේ

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

ඒ නිසා ඉහළින් අවංක විග්‍රහයක් එකතු කරන්න

Cases[
 Import["http://www.stroustrup.com/C++.html", "XMLObject"],
 XMLElement["a", {___, "href" -> link_, ___}, ___] :> 
  link /; StringMatchQ[link, RegularExpression["((http://)?www([./#\\+-]\\w*)+)"]]
, Infinity]

50
නෑ, මම මෙතන කිසිම වංචාවක් දකින්නේ නැහැ. මෙම අභියෝගය වන්නේ ඔබේ භාෂාවේ හොඳම දේ පිටතට ගෙන ඒමයි. එම පළමු පේළිය “කුඩා හා කියවිය හැකි” යන්නෙහි සාරාංශයයි.
මාටින් එන්ඩර්

Ftp සබැඳි අල්ලා ගැනීම පිළිබඳ මෝඩ තර්ක නොසලකා හැරිය හැකි පිළිතුරක්. දීප්තිමත්.
සෙත් බැටින්

මෙම නිශ්චිත විසඳුම ඉදිරිපත් කිරීම සඳහා මෙහි පැමිණියේ, අනෙක් අයද එය අගය කර ඇති බව දැකීම සතුටට කරුණකි.
මයිකල් ස්ටර්න්

@ මාටින්බට්නර් එවැනි අවස්ථාවකදී පහත හෙලීම සලකා බැලීමට ඔබට අවශ්‍ය විය හැකිය meta.codegolf.stackexchange.com/a/1078/12130
ඩේවිඩ් මෝල්ඩර්

6
Av ඩේවිඩ්මුල්ඩර් තාක්ෂණික වශයෙන්, ඡන්දය බිඳවැටීම + 41 / -21 වන බැවින් දැනට අඩුපාඩුව වලංගු නොවේ (සහ අඩුපාඩු ප්‍රශ්නයේ සඳහන් වන්නේ අඩු අගයන් මෙන් දෙගුණයක් තරම් ඉහළ අගයන් තිබේ නම් අඩුලුහුඩුකම් පිළිගන්නා බවයි). සමීප ඇමතුමක්, පිළිගත හැකි නමුත් තවමත්. ;) තවද, මෙය ජනප්‍රිය තරඟයක් මිස කේත ගොල්ෆ් එකක් නොවන අතර විශේෂයෙන් එය ලබා දී ඇති භාෂාවකින් මෙය කොතරම් පහසුවෙන් කළ හැකිදැයි පෙන්වීම පිළිබඳ පොප්-කොන් එකක් වන අතර ඒ නිසා මම සිතන්නේ මෙම අඩුපාඩුව සැබවින්ම අදාළ නොවේ කෙසේ වෙතත් මෙම අභියෝගය (අභියෝගය මූලික වශයෙන් එය ඉල්ලා සිටින බැවින්).
මාටින් එන්ඩර්

116

සී ++

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

ප්රධාන අඩුපාඩුව වන්නේ බූස්ට් හි අමුතු ස්වභාවය :: asio, වඩා හොඳ පුස්තකාලයක් සමඟ එය ඊටත් වඩා කෙටි විය හැකි බව මට විශ්වාසයි.


167
"තෙවන පාර්ශවීය පුස්තකාල නැත" යන්න විහිළුවක් වන්නේ පයිතන් තවමත් විය හැකිය import urllib2, සී 3 තවමත් විය හැකිය using System.Net, හස්කල් තවමත් විය හැකිය import Network.HTTP, නමුත් සී ++ #include <boost/asio.hpp>කෝඩරයක් විශේෂිත, අරමුණු වලින් සාදන ලද සී ++ (සහ සී!) පුස්තකාලවල මෙට්‍රික් ක්‍රැප්ටන් එකක් තිබීම සඳහා නිදහසට කරුණු ඉදිරිපත් කළ යුතුය . ඔබට නිශ්චිත එකක් බලහත්කාරයෙන් පෝෂණය කිරීමට කමිටුව කරදර නොවූ නිසා ලැජ්ජා විය යුතු දෙයකි ...
DevSolar

19
CommentDevSolar 2 වන ගිණුමක් නිර්මාණය කිරීම සඳහා ඔබට එම අදහස් දැක්වීම සඳහා තවත් ඉහළ නැංවීමක් ලබා දී ඇත
පරිශීලක

15
E ඩෙව්සොලර් System.Netබල නොකෙරේ, එය භාෂාව සමඟ ඇතුළත් කර ඇති සියලුම .NET නිර්දේශයන් අනුගමනය කරමින් උසස් තත්ත්වයේ පුස්තකාලයක් පමණි. විකල්ප ක්‍රියාත්මක කිරීම් තිබේ, නමුත් සම්මත පුස්තකාලයේ HTTP සහය තිබීම යනු සරල යෙදුම් ලිවීම සරල ය, තෙවන පාර්ශවීය පුස්තකාල අතර වඩා හොඳ අන්තර්ක්‍රියාකාරිත්වයක් ඇති බව, අඩු පරායත්තතාවයන් අදහස් කරයි, මුහුණත සඳහා පහසුවෙන් ක්‍රියාත්මක කිරීම යනාදිය අදහස් std::stringකරයි. ඔවුන්ගේම පුස්තකාලයක්, එයින් ඇති වන සියලු දුෂ්කරතා ගැන සිතන්න.
අතාරි

17
@DevSolar: urllib2නොවන 3 වන පාර්ශ්ව. එය <iostream>C ++ හි මෙන් stdlib වල ඇත. C ++ මෙන් නොව urllib2පයිතන් හි සෑම විටම ලබාගත හැකිය <boost/asio.hpp>. තෙවන පාර්ශවීය මොඩියුල භාවිතා කිරීමට අපට අවසර ලැබුනේ නම්; මම භාවිතා කරන lxmlහෝ BeautifulSoupPython දී.
jfs

23
එසේම, මෙහි ඇති වැදගත්ම ප්‍රකාශය වන්නේ C ++ එහි සම්මත පුස්තකාලවල වෙනත් භාෂා තරම් ප්‍රමිතිකරණය නොකිරීමයි, නමුත් භාෂාවන්හි සම්මත වන එකම කාර්යයන් සඳහා පුළුල් ලෙස භාවිතා කරන ශක්තිමත් අතේ ගෙන යා හැකි පුස්තකාල තවමත් පවතී. පයිතන් වැනි, සහ මෙම සමහර ලිබ්ස් පාහේ ප්‍රායෝගික ප්‍රමිතියකි. මෙයින් සමහරක් C ++ කුඩා ද්විමය හා කුඩා පුස්තකාල සහිත කාවැද්දූ පද්ධති ඉලක්ක කිරීමට සමත් වීමේ ප්‍රති result ලයකි.
පීටර් කෝර්ඩ්ස්

87

ලිනක්ස් / ඕඑස් එක්ස් හි පිරිසිදු බෑෂ් (බාහිර උපයෝගිතා නොමැත)

HTTP ග්‍රාහක මෘදුකාංග කුප්‍රකට ලෙස පිපිරී ඇත. එවැනි පරායත්තතා අපට අවශ්‍ය නැත. ඒ වෙනුවට අපට සුදුසු ශීර්ෂයන් TCP ප්‍රවාහයකින් පහළට තල්ලු කර ප්‍රති .ලය කියවිය හැකිය. ප්‍රති result ලය විග්‍රහ කිරීම සඳහා grep හෝ sed වැනි පෞරාණික උපයෝගිතා ඇමතීමට අවශ්‍ය නැත.

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

මෙහ් - එය වඩාත් කියවිය හැකි යැයි මම සිතමි ...


1
මේ ආකාරයට පයිප්ප සඳහා යුනික්ස් ගොනු හැසිරවීම් භාවිතා කරයි.
javadba

2
ඇවැත්නි, බාහිර උපයෝගීතා නොමැතිව කෙනෙකුට මෙය කළ හැකි යැයි කිසි විටෙකත් නොසිතුවේය. එල්එෆ්එස් හි මගේ බැෂ් 3.2.17 ඉතා කුඩා යල්පැන ඇති බැවින් එය සහාය නොදක්වයි mapfile:)
රුස්ලාන්

Us රුස්ලාන් යෙප්, mapfileබාෂ් 4.x සමඟ පැමිණේ. එකම දෙය මුළුමනින්ම ලූපයකින් while readකළ හැකිය.
ඩිජිටල් කම්පනය

3
Us රුස්ලාන් මම ඒ while readවෙනුවට වෙනස් කළා mapfile. වඩා අතේ ගෙන යා හැකි සහ කියවිය හැකි යැයි මම සිතමි.
ඩිජිටල් කම්පනය

1
OS X මතද ක්‍රියා කරයි!
ඇලෙක්ස් කෝන්

65

පයිතන් 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

කොරයි, නමුත් ක්රියා කරයි


9
ඇයි ඒ ඇමතුම් ගොඩක් දම්වැල් නොකරන්නේ? l = re.findall('"((http)s?://.*?)"', u.urlopen(s).read())
ව්‍යාජ නම

13
එය කෙටි නමුත් එය මුග්ධ නොවේ (පයිතන් හි කියවීමේ හැකියාව ගණනය කෙරේ)
මුග්ධ

24
හ්ම් ... මගේ සියලු කේත මෙම උදාහරණය වැනි දෝෂ නොසලකා හැරියේ නම්, මා වැඩ කරන සෑම ව්‍යාපෘතියකම 75% සිට 90% දක්වා මගේ වැඩ දැනටමත් සිදු කරනු ඇත.
ඩන්ක්

20
Unk ඩන්ක්: උදාහරණයෙන් යම් ව්‍යතිරේකයක් ඇතිවේ යැයි සිතමු (උදා. urlopen()) බිඳවැටීම සහ මියයාම හැර එවැනි ව්‍යතිරේකයක් සමඟ එය කළ යුත්තේ කුමක්ද? එය කෙසේ හෝ කඩා වැටී මිය යන්නේ නම්, කඩා වැටෙන හා මියයන ආකාරය හැසිරවීමට පයිතන්ට ඉඩ නොදෙන්නේ ඇයි?
කෙවින්

8
Unk ඩන්ක්: මම වෙනත් කෙනෙකුගේ පයිතන් කේතය භාවිතා කරන්නේ නම්, ඔවුන් අල්ලාගෙන ඇමතීමට වඩා (කියන්නට) ඔවුන් වැරදි අල්ලා නොගනී . ඔවුන් දෙවැන්න කරන්නේ නම්, මට අල්ලා ගත යුතුය , එය කිසි විටෙක විනෝදයක් නොවේ. urlopensys.exit("something's borked!")SystemExit
කෙවින්

55

සී #

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

4
ඔබට භාවිතා කළ හැකිය var html, බොහෝ විට var matchඅක්ෂර කිහිපයක් රැවුල කැපීමට.
සුපර්බෙස්ට්

15
Up සුපර්බෙස්ට් මට නම් තනි අක්ෂර බවට පත් කර htmlවිචල්‍යයන් මුළුමනින්ම ඉවත් කළ හැකිය , නමුත් එය මා පසුපසින් නොවේ.
අතාරි

6
Upp සුපර්බෙස්ට් කේත-ගොල්ෆ් නොවේ . : ඩී
ක්‍රොල්ටන්

5
හොඳයි, එය කියවීමේ හැකියාවද වැඩි දියුණු කරයි. varකේත අර්ථ නිරූපණයට එය බලපාන්නේ නැති විට භාවිතා නොකිරීමට හේතුවක් තිබේද?
සුපර්බෙස්ට්

6
Up සුපර්බෙස්ට්: "එය කියවීමේ හැකියාව වැඩි කරයි" ආත්මීය ය. පුද්ගලිකව, මම සිතන්නේ විචල්‍යයේ වර්ගය පැහැදිලිව ප්‍රකාශ කිරීමෙන් කියවීමේ හැකියාව වැඩි දියුණු වේ (සාමාන්‍යයෙන් මෙහි කේතයේ මෙන්). මට මේ ගැන විවාද කිරීමට අවශ්‍ය නැත; විකල්ප අදහස් පවතින බව පෙන්වා දීමට මට අවශ්‍යය.
කෝන්ස්ටැක්ස්

53

"තෙවන පාර්ශවයක් නැත" යනු වැරැද්දකි

මම හිතන්නේ "තෙවන පාර්ශවයක් නැත" යන උපකල්පනය වැරදිසහගත ක්‍රියාවක්. C ++ හි නැවත භාවිතා කළ හැකි කේතයක් සෑදීම එතරම් අපහසු බැවින් C ++ සංවර්ධකයින්ට බලපාන විශේෂිත වැරැද්දකි. ඔබ කිසියම් දෙයක් සංවර්ධනය කරන විට, එය කුඩා පිටපතක් වුවද, ඔබට නැවත ලබා ගත හැකි ඕනෑම කේත කැබැල්ලක් ඔබ සැමවිටම භාවිතා කරනු ඇත.

කාරණය නම්, පර්ල්, පයිතන්, රූබි වැනි භාෂාවලින් (කිහිප දෙනෙකුගේ නම්), වෙනත් කෙනෙකුගේ කේතය නැවත භාවිතා කිරීම පහසු පමණක් නොව, බොහෝ අය බොහෝ විට බොහෝ විට කේත ලියන ආකාරයයි.

සී ++, එහි නඩත්තු කළ නොහැකි-අනුකූල-ඒබීඅයි-අවශ්‍යතාවයන් නිසා එය වඩාත් දැඩි කාර්යයක් වන අතර, ඔබ අවසන් කරන්නේ බූස්ට් වැනි ව්‍යාපෘතියකිනි, එය කේතයේ භයානක ගබඩාවක් වන අතර ඉන් පිටත ඉතා සුළු සංයුක්තතාවයක් ඇත.

CPAN උදාහරණයක්

එහි විනෝදය සඳහා, HTML විග්‍රහ කිරීම සඳහා රීජෙක්ස් භාවිතා කිරීමට උත්සාහ කරනවා වෙනුවට, HTML නිසි ලෙස විග්‍රහ කිරීම සමඟ CPAN මත පදනම් වූ උදාහරණයක් මෙහි ඇත.

#!/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");

6
තෙවන පාර්ශවීය ලිබ්ස් වල ලක්ෂ්‍යය ඇමතීම සඳහා ඉහළට යන්න, නමුත්: කපටි, C ++ හි නැවත භාවිතා කළ හැකි කේතයක් සෑදීම වෙනත් භාෂාවක මෙන් පහසුය. නැවත භාවිතා කළ හැකි කේතයක් භාවිතා කිරීම සහ විශේෂයෙන් සොයා ගැනීම තරමක් අපහසු විය හැකි නමුත් බරපතල ලෙස ගැටළු සහගත එකම දෙය වන්නේ සම්පාදනය කරන ලද කෞතුක වස්තු නැවත භාවිතා කිරීමයි , නමුත් එය බොහෝ විට පර්ල් වැනි අර්ථකථන භාෂාවල ගැටළුවක් නොවේ
මාටින් බා

4
ප්‍රතිසමයක් දිගු කිරීම සඳහා, බූස්ට් CPAN හා සමානයි - තෝරාගෙන තෝරන්න. ඔබ CPAN "කේතයේ භයානක ගබඩාවක්" ලෙස නොකියන්නේ ඔබ භාවිතා නොකරන බොහෝ දේ එහි ඇති නිසාද?
මාටින් බා

22
CPAN යනු එම වචන හතරේ ඕනෑම සාධාරණ අර්ථ දැක්වීමකින් 'කේතයේ භයානක ගබඩාවකි'.
jwg

3
Art මාටින්බා මම එකඟ නොවෙමි, සී ++ සම්පාදනය කරන ලද භාෂාවක් වන අතර, ඒබීඅයි අනුකූලතාව පවත්වා ගැනීම අසීරු බැවින් කේත නැවත භාවිතා කිරීමට බරපතල ලෙස බාධා කරන බැවින් එහි සම්පූර්ණ පරායත්තතාවයන් නැවත ගොඩනඟා ගැනීමට සෑම ක්‍රියාත්මක කළ හැකි ය. C ++ හි නැවත භාවිතා කළ හැකි පුස්තකාලයක් නිෂ්පාදනය කිරීම සඳහා ඔබ නිතරම ABI- නොගැලපෙන වෙනස්කම් වලට බල නොකිරීමට වග බලා ගැනීම සඳහා ඔබට දිගු දුරක් යා යුතුය.
ඩැනියෙල් රුසෝ

6
Ar මාටින්බා ඔබට සරල කාර්යයක් ක්‍රියාත්මක කිරීමට අවශ්‍ය සෑම අවස්ථාවකම මුළු විශ්වයම නැවත ගොඩනඟා ගැනීම දරාගත නොහැකි බැවිනි.
ඩැනියෙල් රුසෝ

47

යුනික්ස් කවචය

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

ftp://සබැඳියක් ද සොයා ගනී :)

://සින්ටැක්ස් මත රඳා නොසිට තවත් ක්‍රමයක් :

lynx -dump -listonly http://www.stroustrup.com/C++.html | sed -n 's/^[ 0-9.]\+//p'

38
වෙබ් පිටුවක් බාගත කිරීම සඳහා වෙබ් බ්‍රව්සරයක් භාවිතා කිරීම රැකියාවට සුදුසු මෙවලමක් වන නිසා හෝ -1 ට +1 කළ යුතුද යන්න මට වැඩ කළ නොහැක. මන්ද අභියෝගය වන්නේ බ්ලාබ්ලාබ්ලා කිරීම සඳහා වැඩසටහනක් ලිවීමයි. දොස් පැවරීම.
ඩේවිඩ් රිචර්බි

2
මම හිතන්නේ ලින්ක්ස් වෙනුවට කර්ල් හෝ විජට් වෙනුවට ආදේශ කිරීම හොඳය. වෙබ් පිටුවක් බාගත කිරීම සඳහා ඒවා වඩාත් බහුලව භාවිතා වේ.
පවෙල් ස්ට්‍රකොව්

4
APavelStrakhov මම ලින්ක්ස් තෝරාගත්තේ එයට විශේෂ දෙයක් නොකර මට සම්බන්ධතා ඉවත දැමිය හැකි බැවිනි :)
රුස්ලාන්

2
Special විශේෂ “ස්ටීව් ජෙසොප්” මම අදහස් කළේ ඇත්ත වශයෙන්ම විග්‍රහ කිරීම හෝ නැවත සකස් කිරීම හෝ ඕනෑම දෙයක්. ලින්ක්ස් සමඟ මම සබැඳි ලැයිස්තුව අතුගා දමමි (ඒවා කරකැවෙන සහ wget ලැයිස්තුගත නොකරයි) සහ අංක ඉවත් කරන්න. ඔබට එය වංචාවක් හෝ වෙනත් දෙයක් ලෙස සැලකිය හැකිය, නමුත් මම සිතුවේ { අවශ්‍ය දේ පරිපූර්ණ ලෙස කරන මෙවලම භාවිතා කිරීම }, ප්‍රතිදානය මනාව සකස් කිරීමයි.
රුස්ලාන්

7
"නමුත් තෙවන පාර්ශවීය පුස්තකාලවලට අවසර නැත" . lynxමෙම තත්වය තුළ එය තෙවන පාර්ශවීය පුස්තකාලයකට ක්‍රියාකාරීව සමාන බව මම තර්ක කරමි .
ඩිජිටල් කම්පනය

43

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

ආකෘතිගත නොකළ ලැයිස්තුවක පිටුවක නිරපේක්ෂ සබැඳි පමණක් පෙන්වීමට මෙම කේතය පරිශීලක ශෛලියක් ලෙස භාවිතා කළ හැකිය. ඔබගේ බ්‍රව්සරය අවම අකුරු ප්‍රමාණය බලාත්මක කරන්නේ නම් එය නිවැරදිව ක්‍රියා නොකරනු ඇත.

එය නිවැරදිව ක්‍රියා කරයි http://www.stroustrup.com/C++.html(සටහන!important මත background). තවත් මෝස්තර සහිත වෙනත් පිටුවල වැඩ කිරීම සඳහා, එය දිගු කළ යුතුය (වැඩි ගුණාංග නැවත සකසන්න, ගුණාංග වැදගත් ලෙස සලකුණු කරන්න).

හැෂ් වලින් ආරම්භ වන අන්තර් සම්බන්ධක සම්බන්ධතා හැර සාපේක්ෂ සබැඳි ඇතුළත් විකල්ප අනුවාදය (එය අවාසනාවකට දෘඩ කේත සහිත නිරපේක්ෂ සම්බන්ධකයක් මත රඳා පවතී):

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

16
මම දැකපු නරකම දේ මෙයයි. +1
එමෙට් ආර්.

1
මෙය ලස්සන හා සම්පූර්ණයෙන්ම භයානක ය. +1
ricdesi

37

Clojure

(->> (slurp "http://www.stroustrup.com")
     (re-seq #"(?:http://)?www(?:[./#\+-]\w*)+"))

28
මුඩුක්කු ?! මට ක්ලෝජුර් ඉගෙන ගැනීමට අවශ්‍යයි.
11684

10
@ 11684 - ද Clojure නම් සම්මත කාර්යයන් spit, zipperසහ lazy-cat... :-)
බොබ් Jarvis - නැවත සේවයේ පිහිටුවීමට මොනිකා

2
වාව්, මම හිතන්නේ එය ප්‍රමාද වූ අලුත් අවුරුදු යෝජනාවක් වනු ඇත. @BobJarvis
11684

31

ඉමාක්ස් ලිස්ප්

(with-current-buffer (url-retrieve-synchronously "http://www.stroustrup.com/C++.html")
  (while (re-search-forward "https?://[^\\\"]*")
    (print (match-string 0))))

2
මෙම කේතය කොතරම් සංයුක්ත හා කැපී පෙනෙන ලෙස කියවිය හැකිද යන්නට වඩා වැඩි ඡන්ද ප්‍රමාණයක් නොමැති නිසා මම ටිකක් විසුරුවා හරිමි. හොඳට කලා.
ස්පේස්මූස්

28

පරිමාණය

"""\"(https?://.*?)\"""".r.findAllIn(scala.io.Source.fromURL("http://www.stroustrup.com/C++.html").mkString).foreach(println)

8
සෑම දෙයක්ම එක පේළියකින් ඇසුරුම් කරන්න - C ++
ටද

කුමක් ගැනද ftp://ftp.research.att.com/pub/c++std/WP/CD2?
ටොබියාස් කියෙන්ස්ලර්

22
etquetzalcoatl - මෙය එක් පේළියක් පමණක් නොව එක් ප්‍රකාශනයකි . ඔබට C ++ කේතයෙන් සියලුම රේඛා බිඳීම් මකා දැමිය හැකිය, නමුත් එය එකම ප්‍රකාශනයකින් සම්පූර්ණ කාර්යය කිරීම හා සමාන නොවේ.
ඩාවෝවන්

4
A ඩාවෝවන්: කණගාටුයි, නමුත් ප්‍රකාශන එදිරිව එදිරිව ආරම්භ කිරීම මෝඩ වැඩකි. සමහර ෆන්ක්ටර්ස් සහ සී ++ එකතු කරන්න ඔබටත් එය කළ හැකිය. නමුත් එය “ප්‍රදානය” ලෙස සලකන සහ “ඇතුළත ශුන්‍ය කේතයක්” ඇති දේ කුමක්ද යන ප්‍රශ්නය පමණි. එය රේඛාවකට ඇසුරුම් කිරීම කියවීමේ හැකියාව ඉක්මන් කරයි යන කාරණය එය වෙනස් නොකරයි. යමෙකුට එය තවමත් තනි ප්‍රකාශනයක් ලෙස තබා ගත හැකි අතර එය පේළි කිහිපයකට නැවත හැඩගස්වා බොහෝ දේ ලබා ගැනීමට සහ රේඛීය ගණන හැර වෙන කිසිවක් ලිහිල් කළ නොහැක. ඒක තමයි මගේ අදහස. මෝඩ ඇසුරුම් - C ++ ටද එය කළ හැකිය. යමෙකුට "මෝඩ ඇසුරුම්" කොටුවෙන් ඉවත් වීමට අවශ්‍ය නම්, රේඛාව ගණනය කිරීම නොව කියවීමේ හැකියාව සඳහා කේතය සංයුති කළ යුතුය.
quetzalcoatl

3
etquetzalcoatl ටොබියාස් අපට එය අනුගමනය කිරීම සඳහා සබැඳිය එහි තබා නැත. ඔහු මෙම පිළිතුර ලියූ ලේඛකයාගෙන් විමසුවේ එය ඔහුගේ ප්‍රති .ලවල නොතිබුණේ මන්ද යන්නයි.
ජේ.එල්.රිෂේ

25

PHP 5

<?php
preg_match_all('/"(https?:\/\/.*?)"/',file_get_contents('http://www.stroustrup.com/C++.html'),$m);
print_r($m[1]);

5
යෝජිත සංස්කරණයන්: '/"((http)s?://.*?)"/''|"((http)s?://.*?)"|'(දැනට දෝෂයකි); ඉවත් කරන්න array_unshift($m);(දැනට දෝෂයකි, array_shiftඒ වෙනුවට ඔබ අදහස් කළේ ); ( print_r($m);යූආර්එල් print_r($m[1]);පමණක් ප්‍රතිදානය කරන්න).
primo

ස්ථාවරයි, ඔබගේ ආදානයට ස්තූතියි
ඩේවිඩ් ෂු

Av ඩේවිඩ්වි ඔබ හැර එය නිවැරදි නොකළේ නම් ...?
ෂහාර්

දැන් එය ස්ථාවරයි.!
ඩේවිඩ් ෂු

24

පවර්ෂෙල්

සම්පුර්ණ සුදුසුකම් ලත් සියලුම URL සඳහා පෙළ සෙවීම (ජාවාස්ක්‍රිප්ට්, CSS, ආදිය ඇතුළුව):

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

හෝ නැංගුරම් ටැග් වලින් පමණක් සබැඳි ලබා ගැනීමට (සාපේක්ෂ URL ඇතුළත්):

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

අදහස් වලින් කෙටි අනුවාද:

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

6
යමෙකු පුදුම iwrවන්නේ නම්, Invoke-WebRequest(PS3 +) සඳහා අන්වර්ථයකි .
අතාරි

8
එකතු කිරීම් සමතලා කර ගැනීමට පවර්ෂෙල්ගේ උනන්දුව ඔබට අනිසි ලෙස භාවිතා කළ හැකිය: (iwr "http://www.stroustrup.com/C++.html").Links.href(හෝ (iwr "http://www.stroustrup.com/C++.html").Links.href-match":"නිරපේක්ෂ යූආර්අයි සඳහා පමණි)
මතියස් ආර්. ජෙසන්

1
ඒක හරිම පහසුයි!
ජස්ටින් ඩන්ලැප්

22

ඩී

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

ලැයිස්තුව මුල් උදාහරණයට සමාන කිරීමට, ඔබට වැඩසටහනේ ප්‍රතිදානය නල මාර්ගයෙන් | sort | uniqහෝ ඒ වෙනුවට import std.arrayපේළිය එකතු කර වෙනස් කළ .filter!("a")){ writeln(_.front[1]); }හැකිය : .filter!("a").map!(a => a.front[1]).array.sort.uniq){ writeln(_); }. කෙසේ වෙතත්, මම මෙම කේතය උත්සාහ කර ඇති අතර එය නිවැරදි හෝ “මුග්ධ” බව ඔප්පු කර නොමැති බව සලකන්න. :)
Frg

22

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

3
මම හිතන්නේ require('http').getවැඩ කරනවද කියලා. එසේ වුවහොත් අපට var ප්‍රකාශය ඉවත් කර තවත් පේළියක් කෙටි කළ හැකිය.
යුනිහෙඩ්‍රොන්

N යුනිහෙඩ්‍රෝ එය කරයි.
ටිම්වොල්ලා

9
N යුනිහෙඩ්‍රෝ එය සිදු කරයි, නමුත් මෙය ගොල්ෆ් ක්‍රීඩාවක් නොවේ.
cPu1

අල්ලා ගැනීමේ කණ්ඩායම් භාවිතා කිරීමට ඔබට අවශ්‍ය නැත.
රයි-

මම හිතන්නේ එය රාමු නාමයකට වඩා ජාවාස්ක්‍රිප්ට් ය.
mr5

21

හස්කල්

"\w"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

resultනිශ්චිතව දක්වා ඇති වර්ගය පැහැදිලිව සඳහන් කරන්නේ ඇයි? එය භාවිතා කිරීමෙන් එය සම්පූර්ණයෙන්ම සීමා කළ යුතුය unlines.
ජෝන් ඩ්වොරක්

1
මෙම දික් වන්නේ ද නැත ලෙස දැක, ටිකක් පාලනය Network.HTTPහෝ TextRegex.Posixදී සිටින්නේ baseපැකේජය. (ඔවුන් Haskell වේදිකාව, සහ ඇත්ත Hackage මත වුවද, ඒ නිසා ...)
counterclockwis හැරී නතර

1
An ජැන්ඩ්වොරක්, මම ghci වලින් ලිවීමට පටන් ගනිමි (බොහෝ විට මම එය නොවෙනස්ව පළ කළ යුතුය). නමුත් ඔබේ සටහන අදාළයි, ස්තූතියි.
ව්ලැස්ටාචු

ftleftaroundabout, දැන සිටියේ නැත. මූලික පැකේජය භාවිතා කර ඇත්නම් මට එය කළ නොහැකි බව පෙනේ.
ව්ලැස්ටාචු

networkමේ baseදෙකෙහිම නැත, එබැවින් ඔබේම සොකට් බන්ධන පෙරළීම සඳහා ඉතිරි කරන්න එය සාධාරණ ලෙස කිරීමට ප්‍රායෝගික ක්‍රමයක් නොමැත base.
ලැම්බඩා සුරංගනාවිය

20

රූබි

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

1
ඔබේ රීජෙක්ස් අසමත් වනු ඇත, ඔබ භාවිතා කළ %r{"(https?://[^"]+)"}යුතුය. Net::HTTP.get('www.stroustrup.com', '/C++.html')ඉල්ලීම කෙටි කිරීමට ඔබට භාවිතා කළ හැකිය (සහ එය කියවිය හැකි ලෙස තබා ගන්න). එබැවින් සම්පූර්ණ කේතය එක පේළියක විය හැකිය (එය කියවිය හැකි ලෙස තබා ගැනීම) : puts Net::HTTP.get("www.stroustrup.com", "/C++.html").scan(%r{"(https?://[^"]+)"}). එය සමඟ ධාවනය කරන්න, ruby -rnet/httpඔබට require 'net/http'රේඛාවක් පවා අවශ්‍ය නොවේ .
හෝලෙත්

18

PHP

මට කිව හැකි පරිදි, බොහෝ නවීන PHP ස්ථාපනයන් DOM සැකසුම් සමඟ එන බැවින් 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;
    }
}

අභ්යන්තර ලූපය කෙටි කළ හැක්කේ:

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

ඇත්ත වශයෙන්ම මෙය පැමිණීමට අවශ්‍ය විය (මෙහි මගේ පළමු පිළිතුර ලෙස). ඔබ එය මුලින්ම කළේ, එබැවින් මෙන්න ඔබේ +1 (දෝෂ සහිත රීජෙක්ස් භාවිතා නොකිරීම සඳහා)! ඉඟිය: ඔබ කොර භාවිතා කළ හැකි 1, ඒ වෙනුවට ඇති trueකිරීම සඳහා in_arrayදැඩි, සොයන්න. ඔබට වරහන් මඟ හැරිය හැක. මට සම්පුර්ණයෙන්ම විශ්වාස නැත, නමුත් ඔබට එය අතහැර දැමිය හැකි httpඅතර ://(යෝජනා ක්‍රමයට යන්න). .
කයිසර්

සහ: තවත් හැකියාවක් වනුයේ if ( ) {}පක්ෂව ඡන්දය දීමයි in_array() and print $url.PHP_EOL. නමුත් ඔව්, ඔබට වඩාත් හොඳ කියවීම සඳහා තවත් +1 (මට හැකි නම්) ලැබෙනු ඇත :)
කයිසර්

ඔබේ උදාහරණය අත්හදා බලා දැඩි ප්‍රමිතීන් සඳහා දෝෂයක් ඇතිවිය (PHP 5.4). මූලාශ්‍රයේ මෙන්, නැතිවූ අර්ධ සළකුණක් සමඟ දූෂිත හෝ වැරදි ලෙස ආකෘතිගත කළ සම්බන්ධයක් කොතැනක හෝ ඇති බව පෙනේ. භාවිතා කිරීමෙන් ඔබට දෝෂ වාර්තා කිරීම අක්‍රිය කළ හැකිය @\DOMDocument. එය උත්සාහ කර එය ක්‍රියාත්මක වන බව තහවුරු කළ හැකිය.
කයිසර්

නැහැ, එය වැරදි ලේඛනයකි; තාක්‍ෂණිකව ඔබ ::loadHTMLFile()සංඛ්‍යාත්මකව ඇමතිය යුතු නැත , එකතු කිරීමෙන් @එම පුරාවස්තු සැඟවිය හැක.
ජැක්

2
මෙය නියත වශයෙන්ම වඩාත්ම “නිවැරදි” විසඳුම්වලින් එකක් වන අතර, නිෂ්පාදනයේ දී මට දැකිය හැකි එකම විසඳුම මෙයයි. හොඳ වැඩක්
ජෝර්ඩන් බයෝඩෝ

14

යුනික්ස් ෂෙල්

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

මා පිළිගත යුතු වුවත්, පේළියක එක් සම්බන්ධකයකට වඩා තිබේ නම් මෙය ක්‍රියා නොකරයි.


1
curl http://www.stroustrup.com/C++.htmlඅක්ෂර කිහිපයක් ඉතිරි කරයි.
l0b0

7
"නමුත් තෙවන පාර්ශවීය පුස්තකාලවලට අවසර නැත" . මම හිතන්නේ wgetGNU (bash ලෙස) බැවින් ඔබට එය තෙවන පාර්ශවයක් නොවන බවට තර්ක කළ හැකිය. නමුත් curlඅනිවාර්යයෙන්ම තෙවන පාර්ශවයකි.
ඩිජිටල් කම්පනය

ගැන ftp://ftp.research.att.com/pub/c++std/WP/CD2සහ https://www.youtube.com/watch?v=jDqQudbtuqo&feature=youtu.be?
ටොබියාස් කියෙන්ස්ලර්

4
Ob ටොබියාස් කියන්ස්ලර් මම හිතන්නේ ස්ට්‍රෝස්ට්‍රප්ගේ මුල් කේතය ඒවා සොයාගත නොහැකි විය
රුස්ලාන්

14

ජාවා

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

3
ඔබේ පිළිතුරු වල කේතය නිසි ලෙස සංයුති කළ හැකිද? එය අවම වශයෙන් කියවිය හැකි කේතය සඳහා තරඟයක් නොවේ. අවම වශයෙන් තිරස් අනුචලන වළක්වා ගැනීමට ඔබට එය සංයුති කළ හැකිය.
අතාරි

ඔබ එය භාවිතා කරන්නේ Scannerනම්, එය සෘජුවම සබැඳි සඳහා රීජෙක්ස් රටාව සැකසීමට සහ ප්‍රති .ල හරහා නැවත සැකසීමට හැකිය Scanner.
හොල්ගර්

5
ඔව් .. ඒක ඔයාට ජාවා. කේත ගොල්ෆ් සඳහා එය භාවිතා කිරීම නිර්භීත කාර්යයකි.
javadba

4
C ++ ට වඩා කෙටි වන ජාවා විසඳුමක් මා දකිනු ඇතැයි කිසි විටෙකත් නොසිතුවෙමි!
slebetman

2
මගේ අන්තිම අදහස් දැක්වීම නිවැරදි කිරීම: මෙය ජාවා හි ලිවිය හැකි කෙටිම හා පිරිසිදුම කේතය බව මම පිළිගත යුතුය. මම සැක්ස් පාර්සර් ප්‍රවේශයක් අත්හදා බැලුවෙමි, එය ලැම්බඩාස් සමඟ ඊටත් වඩා කෙටි කළ හැකිය, නමුත් වෙබ් පිටුව XHTML නොවන අතර පාර්සර් ව්‍යතිරේකය විසි කරයි. යා යුතු එකම මාර්ගය රෙජෙක්ස් ය.
මිස්ටර් ස්මිත්

11

ග්‍රෝවි

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

භාවිතා කිරීමෙන් වැඩි දියුණු කළ හැකිද?. NPE වලින් වැළකී සිටීමට ක්‍රියාකරු?
ක්‍රිස් කේ

2
H ක්‍රිස්කමින්ස්කි සහ දෝෂ පරීක්ෂා කිරීම සඳහා මෙහි පළමු (බර්න් අසල) විය හැකිද? කවදාවත්! ඒ හැර: මම මෙහි දකින්නේ IO ආශ්‍රිත ව්‍යතිරේක පමණි. ඔබ NPE දකින්නේ කොහේද?
cfrick

findAll () හට නැවත ශුන්‍ය විය හැකිය, නැත? නැතහොත් එය හිස් ලැයිස්තුවක් ලබා දෙයිද? ග්‍රෝවිට තව ටිකක් අලුත්. සංස්කරණය කරන්න: nm, findAll () හිස් ලැයිස්තුවක් ලබා දෙන බව පෙනේ. ඒ ග්‍රෝවි කොල්ලෝ හරිම දක්ෂයි. :-)
ක්‍රිස් කේ

11

SQL (SQL Anywhere 16)

වෙබ් පිටුව ලබා ගැනීම සඳහා ගබඩා කළ ක්‍රියා පටිපාටියක් නිර්වචනය කරන්න

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

තනි විමසුමක් භාවිතයෙන් ප්‍රති set ල කට්ටලය නිෂ්පාදනය කරන්න

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;

සීමාවන්: මෙය සබැඳි 256 ක් දක්වා නිපදවයි. තවත් සබැඳි තිබේ නම්, 256 සුදුසු අගයකට ඔසවන්න.


2
SQL හි ගොල්ෆ් ක්‍රීඩාවක් ඇතැයි මම විශ්වාස නොකළෙමි ... මේ වන තෙක්.

මට තේරුණා ... "සබැඳි". :-)
ජැක් එස්ඒපී කැනඩාවේ

10

කෝපි ස්ක්‍රිප්ට් / නෝඩ්ජේඑස්

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

1
මම හිතන්නේ මේක කෝපි ස්ක්‍රිප්ට් / නෝඩ් එකක්ද? මම හිතන්නේ ඔබ එය නියම කළ යුතුයි ...
ජෝන් ඩ්වොරක්

වොව්. එය ඉතා කියවිය හැකි ය.
slebetman

le ස්ලෙබෙට්මන් එය නිසැකවම කුඩා වුවත්
ජෝන්

@slebetman ඔව් කෝපි ස්ක්‍රිප්ට් ජාවාස්ක්‍රිප්ට් වලට වඩා බොහෝ සෙයින් කියවිය හැකිය :) සියලු කැරලි වරහන් ඉවත් කිරීමට ලැබීම ගැන මම සතුටු වෙමි} :)
RobAu

9

පර්ල්

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;

1
ඔබ ක්ෂේත්‍ර බෙදුම්කරු සහ වාර්තා-බෙදුම් විචල්‍යයන් මඟ හැර, එසේ කළහොත් කේතය වඩාත් පැහැදිලි වනු ඇත: මුද්‍රණ සිතියම {"$ _ \ n"} $ ප්‍රතිචාරය-> අන්තර්ගතය = ~ m <"(https ?: //.+ ?) "> උ;
ඩැනියෙල් රුසෝ

An ඩැනියෙල් රූසෝ එකඟ විය.
primo

හෝ use v5.10;සහ say for $response->content...
මාක් රීඩ්

එක් එක් කෙනාට, මම හිතන්නේ. පසුපෙළ කරන ලද perl6 විශේෂාංග සමහරක් ගැටළු සහගතය (ස්මාර්ට් ගැලපීම, මම ඔබ දෙස බලමි), නමුත් sayඑය බෙහෙවින් ප්‍රයෝජනවත් වන අතර මගේ මනසෙහි මෙහි පැහැදිලි වේ. (එසේම, පසුගිය වසර 13 තුළ perl5 සඳහා සම්පූර්ණයෙන්ම සම්බන්ධයක් නැති perl6ism වැඩිදියුණු කිරීම් බොහෝමයක් සිදුවී ඇත; එය පරීක්ෂා කිරීම වටී.)
මාර්ක් රීඩ්

Ark මාක්රීඩ් sayමෙම අවස්ථාවේ දී එය වඩාත් කියවිය හැකි බව මම එකඟ වෙමි , විශේෂයෙන් පර්ල් ගැන එතරම් දැනුමක් නැති අයට.
primo

9

ආර්

html<-paste(readLines("http://www.stroustrup.com/C++.html"),collapse="\n")
regmatches(html,gregexpr("http[^([:blank:]|\\\"|<|&|#\n\r)]+",html))

R ප්‍රධාන වශයෙන් C හි ලියා ඇතත් ... එම නිසා R කේතයේ පේළි 2 පිටුපස C කේත පේළි කිහිපයක් තිබිය හැකිය.


2
මෙහි ඇති සියලුම පිළිතුරු සඳහා එය (හෝ ඊට සමාන දෙයක්) සත්‍ය වේ.
ජේ.එල්.රිෂේ

8

පරමාර්ථය-සී

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

3
කුමක්ද? කරුණාකර ස්විෆ්ට් අනුවාදය ලියන්න. එම චතුරස්රාකාර විකාරය මගේ ඇස්වලට රිදවයි :)
මිස්ටර් ස්මිත්

2
[] සඳහා හුරේ! එසේම, අපි මුළුමනින්ම
ස්මාල්ටෝක්

Ister මිස්ටර් ස්මිත් ස්විෆ්ට් පිළිතුර දැන් මෙහි ඇත.
JAL

7

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]

කට්ටල තුළ http :: දත්ත කිරීමෙන් ඔබට ගැලවිය හැකිය. තාවකාලික විචල්‍යයක් නිර්මාණය කිරීම අවශ්‍ය නොවේ. ඒ වගේම මම සෑම දෙයක්ම නව රේඛා දමා ඉන්ඩෙන්ට් කිරීමෙන් එය සංයුති කරමි [. නමුත් එය විලාසිතාවේ තේරීමක්.
slebetman

7

යන්න

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 මෙම කේතය මුළු ප්‍රභවයම මතකයට කියවයි, එබැවින් regexp.FindReaderIndexප්‍රවාහය තුළ සෙවීම සඳහා සලකා බලන්න, එමඟින් යෙදුම වෙඩි නොවදින බවට පත් වේ.


6

සී

CJam හට රීජෙක්ස් නොමැති බැවින් මට මේ සම්බන්ධයෙන් වෙනස් ප්‍රවේශයක් භාවිතා කිරීමට සිදුවිය:

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

මම සියලු පළමු ආගමට හරවා 'ගැනීමට ", සියලු මත මම භේදය ", නූල් සඳහා ලැයිස්තුව සමඟ ආරම්භ බව පෙරහන අවසානයේ එවකට සෑම විකල්ප සංගීත ගෙන http://හෝ https://. ඊට පසු, පෙරහන් කළ සෑම නූලක්ම නව පේළියක මුද්‍රණය කරන්න.

වැනි ජාවා පරිවර්තකය භාවිතා කර එය උත්සාහ කරන්න

java -jar cjam-0.6.2.jar file.cjam

file.cjam හි ඉහත කේතයේ අන්තර්ගතය ඇත.


9
කියවිය හැකි කොටස ගැන නොදන්න ... Cjam වෙබ් ක්‍රියාකාරිත්වය ඇති බව දැන සිටියේ නැත
Def

ඔබට එය ගොල්ෆ් කිරීමට අවශ්‍ය නම් ... ''/'"f/:+සඳහා ''/'"*'"/'"f/0f=.
jimmy23013

... ඉන්න ඇයි ඉන්නේ '"f/0f=? එය යමක් කළ යුතුද ( 2%උදාහරණයක් ලෙස)?
jimmy23013

6

එෆ් #

මෙම කේතය වඩා කෙටි විය හැකි නමුත් මෙම කේතය නැවත කියවීමට හෝ භාවිතා කිරීමට මට කවදා හෝ බලාපොරොත්තු වූවා නම් මම මේ වගේ දෙයක් ලියමි. එය ක්රියාකාරී රටාව භාවිතය පෙන්නුම් MatchValue සම්මත CLR වර්ගය එරෙහිව රටා ගැළපුම් සක්රීය කිරීම තරගයේ

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)

සංස්කරණය මම getLinks තමන්ගේම කාර්යයක් බවට පත් කළෙමි


මම ඇත්තටම කැමතියි ඔබ වර්ගීකරණ විවරණ භාවිතා කළ ආකාරය. ඔබ ආපසු එන්නේ කුමක් දැයි විස්තර කිරීමට අගයන් නම් කිරීම හරි යැයි මම සිතමි, නමුත් ශ්‍රිතයේ නම ප්‍රමාණවත් තරම් ප්‍රකාශිත ය: getHTML සහ html අගය, getLinks සහ සබැඳි වටිනාකම. අවසාන පේළි දෙක සබැඳි විය හැකිය |> Seq.iter (printfn "% s")
මයිකල්මා

Ic මිචල්මා ශ්‍රිතයේ නම තනිවම ප්‍රකාශ වන බව මම එකඟ වෙමි, ප්‍රායෝගික හේතුන් මත html සහ සම්බන්ධක විචල්‍යයන් ඇත: එබැවින් බ්‍රේක්පොයින්ට් එකක් සැකසීමට කොහේ හරි තිබේ. List.iter වෙනුවට for for loop භාවිතා කළේ එය වැඩිපුර කියවන ආකාරයට මා කැමති නිසා ය.
SourceSimian
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.