HTTP: Difference between revisions

=={{header|8th}}==

"http://www.rosettacode.org" net:get drop >s .

=={{header|ABAP}}==

This works for ABAP Version 7.40 and above

report z_http.

write / <output_line>.

endloop.

{{out}}

=={{header|ActionScript}}==

package

{

}

}

=={{header|Ada}}==

{{libheader|AWS}}

with Ada.Text_IO; use Ada.Text_IO;

Put_Line (AWS.Response.Message_Body (AWS.Client.Get (URL => "http://www.rosettacode.org")));

end HTTP_Request;

=={{header|ALGOL 68}}==

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of ''grep in string'' and ''http content''}}

STRING domain="rosettacode.org";

STRING page="wiki/Main_Page";

ELSE print (strerror (rc))

FI

=={{header|Amazing Hopper}}==

#include <hopper.h>

main:

{"Size = ",lenght,"\nContent = \n",s}println

exit(0)

{{out}}

<pre>

=={{header|Arturo}}==

=={{header|AutoHotkey}}==

UrlDownloadToFile, http://rosettacode.org, url.html

Run, cmd /k type url.html

=={{header|AWK}}==

{{works with|gawk}}

site="en.wikipedia.org"

path="/wiki/"

print ship

=={{header|BaCon}}==

' Read and display a website

'

CLOSE NETWORK mynet

PRINT total$

=={{header|Batch File}}==

curl.exe -s -L http://rosettacode.org/

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

SYS "GetProcAddress", urlmon%, "URLDownloadToFileA" TO URLDownloadToFile

IF fail% ERROR 100, "File download failed"

=={{header|Biferno}}==

simple one-liner using httpExt and quick print $

=={{header|C}}==

{{libheader|libcurl}}

#include <stdio.h>

#include <stdlib.h>

return EXIT_SUCCESS;

}

=={{header|C sharp}}==

using System;

using System.Text;

}

}

=={{header|C++}}==

#include <winsock2.h>

#include <ws2tcpip.h>

return 0;

}

{{libheader|U++}}

#include <Web/Web.h>

Cout() << HttpClient("www.rosettacode.org").ExecuteRedirect();

}

=={{header|Caché ObjectScript}}==

=={{header|Clojure}}==

Using the Java API:

(defn get-http [url]

(let [sc (java.util.Scanner.

(println (.nextLine sc)))))

(get-http "http://www.rosettacode.org")

Using <code>clojure.contrib.http.agent</code>:

(ns example

(:use [clojure.contrib.http.agent :only (string http-agent)]))

(println (string (http-agent "http://www.rosettacode.org/")))

{{works with|Clojure|1.2}}

(print (slurp "http://www.rosettacode.org/"))

=={{header|COBOL}}==

Tested with GnuCOBOL

identification division.

program-id. curl-rosetta.

goback.

and a copybook

*> Usage: COPY occurlsym inside data division

*> Taken from include/curl/curl.h 2013-12-19

03 FILLER PIC X(30) VALUE "CURLE_AGAIN ".

01 FILLER REDEFINES LIBCURL_ERRORS.

{{out}}

=={{header|ColdFusion}}==

<cfhttp url="http://www.rosettacode.org" result="result">

<cfoutput>#result.FileContent#</cfoutput>

=={{header|Common Lisp}}==

CLISP provides an extension function to read http sources. Other implementations may do this differently.

{{works with|CLISP}}

(defun wget-clisp (url)

(ext:with-http-input (stream url)

while line

do (format t "~a~%" line))))

{{libheader|DRAKMA}}

First grabbing the entire body as a string, and then by pulling from a stream (as in the CLISP example).

(defun wget-drakma-string (url &optional (out *standard-output*))

"Grab the body as a string, and write it to out."

while line do (write-line line out)

finally (close body)))

{{libheader|Dexador}}

(format t "~a~%" (nth-value 0 (dex:get "http://www.w3.org/")))

=={{header|Crystal}}==

require "http/client"

HTTP::Client.get("http://google.com")

=={{header|D}}==

{{libheader|phobos}}

void main() {

import std.stdio, std.net.curl;

writeln(get("http://google.com"));

}

{{libheader|tango}}

import tango.io.Console;

import tango.net.http.HttpGet;

Cout.stream.copy( (new HttpGet("http://google.com")).open );

}

Or more operating directly on the socket:

import tango.io.Console;

import tango.net.InternetAddress;

Cout.stream.copy (site);

}

=={{header|Dart}}==

Using the stand-alone VM:

void main(){

var url = 'http://rosettacode.org';

.then((HttpClientRequest request) => request.close())

.then((HttpClientResponse response) => response.pipe(stdout));

=={{header|Delphi}}==

Simple example using the free Synapse TCP/IP library [http://www.ararat.cz/synapse/doku.php/download]

program HTTP;

end.

Using Indy:

program ShowHTTP;

end;

end.

=={{header|Dragon}}==

select "std"

http("http://www.rosettacode.org", ::echo)

=={{header|E}}==

when (def t := <http://www.rosettacode.org> <- getText()) -> {

println(t)

}

=={{header|EchoLisp}}==

'''file->string''' usage: the server must allow cross-domain access, or a browser add-on like cors-everywhere must be installed to bypass cross-domain checking.

;; asynchronous call back definition

(define (success name text) (writeln 'Loaded name) (writeln text))

;;

(file->string success "http://www.google.com")

=={{header|Emacs Lisp}}==

<code>url-retrieve-synchronously</code> returns a buffer containing headers and body. Caller must kill the buffer when no longer needed.

(unwind-protect

(with-current-buffer buffer

(message "%s" (buffer-substring url-http-end-of-headers (point-max))))

Asynchronously (buffer doesn't need to be killed by caller):

(lambda (_status)

=={{header|Erlang}}==

===Synchronous===

-module(main).

-export([main/1]).

{error, Res} -> io:fwrite("~p~n", [Res])

end.

===Asynchronous===

-module(main).

-export([main/1]).

after 10000 -> io:fwrite("Timed out.~n",[])

end.

Using it

|escript ./req.erl http://www.rosettacode.org

=={{header|F_Sharp|F#}}==

In F# we can just use the .NET library to do this so its the same as the [[C_sharp|C#]] example.

let wget (url : string) =

use c = new System.Net.WebClient()

printfn "%s" (wget "http://www.rosettacode.org/")

However unlike C#, F# can use an asynchronous workflow to avoid blocking any threads while waiting for a response from the server. To asynchronously download three url's at once...

open System.Net

open System.IO

|> List.map wgetAsync

|> Async.Parallel

=={{header|Factor}}==

"http://www.rosettacode.org" http-get nip print

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

This works at the socket level, returning both the HTTP headers and page contents.

include unix/socket.fs

dup pad 8092 read-socket type

close-socket

=={{header|FreeBASIC}}==

urlfile="start http://rosettacode.org/wiki/Main_Page"

Print !"\n--- pulsa RETURN para continuar ---"

=={{header|friendly interactive shell}}==

{{trans|UNIX Shell}}

{{works with|BSD}}

=={{header|Frink}}==

Frink's <CODE>read[<I>URL</I>]</CODE> function works with any URL type supported by your Java Virtual Machine, and returns the results as a single string.

print[read["http://frinklang.org/"]]

=={{header|Gastona}}==

<main>

LOOP, TEXT FILE, http://www.rosettacode.org

, BODY, @<value>

=={{header|GML}}==

'''Any Event'''

'''HTTP Event'''

{

show_message_async(ds_map_find_value(async_load,"result"));

=={{header|Go}}==

package main

io.Copy(os.Stdout, r.Body)

}

Output:

=={{header|Groovy}}==

new URL("http://www.rosettacode.org").eachLine { println it }

=={{header|GUISS}}==

It would be more appropriate to paste to notepad:

Click:Area:browser window,Type:[Control A],[Control C],Start,Programs,Accessories,Notepad,

=={{header|Halon}}==

=={{header|Haskell}}==

Using {{libheader|HTTP}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Network.Browser

import Network.HTTP

request $ getRequest "http://www.rosettacode.org/"

putStrLn $ rspBody $ snd rsp

== Icon and Unicon ==

==={{header|Icon}}===

link cfunc

procedure main(arglist)

while write(read(f))

end

Using it

|icon req.icn http://www.rosettacode.org

==={{header|Unicon}}===

Unicon provides improved socket and messaging support without the need for the external function ''cfunc'':

procedure main(arglist)

m := open(arglist[1],"m")

while write(read(m))

end

=={{header|J}}==

Using <tt>gethttp</tt> from [[Web Scraping#J|Web Scraping]]

gethttp 'http://www.rosettacode.org'

=={{header|Java}}==

Using the standard [http://openjdk.java.net/groups/net/httpclient/ Java 11 HTTP Client]

import java.net.http.HttpClient;

import java.net.http.HttpRequest;

.join();

}

{{libheader|Apache Commons IO}}

import org.apache.commons.io.IOUtils;

import java.net.URL;

IOUtils.copy(new URL("http://rosettacode.org").openStream(),System.out);

}

=={{header|JavaScript}}==

===Browser===

req.onload = function() {

console.log(this.responseText);

req.open('get', 'http://rosettacode.org', true);

Using fetch API:

fetch('http://rosettacode.org').then(function(response) {

return response.text();

console.log(myText);

});

As a repeatable function:

* @name _http

* @description Generic API Client using XMLHttpRequest

.join("&")

}

Using jQuery:

console.log(data);

===Node.js===

With Node.js, using only the included http module.

http.get('http://rosettacode.org', (resp) => {

}).on("error", (err) => {

console.log("Error: " + err.message);

=={{header|Jsish}}==

Based on Jsi_Wget that ships with Jsish.

function httpGet(fileargs:array|string, conf:object=void) {

if (isMain())

{{out}}

=={{header|Julia}}==

=={{header|Kotlin}}==

import java.net.URL

while (sc.hasNextLine()) println(sc.nextLine())

sc.close()

=={{header|Lasso}}==

incude_url is a wrapper for Lasso's curl datatype, however it can be achieved in several ways.

include_url('http://rosettacode.org/index.html')

local(x = curl('http://rosettacode.org/index'))

local(y = #x->result)

=={{header|LFE}}==

===Synchronous===

(case (: httpc request '"http://lfe.github.io")

((tuple 'ok result)

((tuple 'error reason)

(: io format '"Error: ~p~n" (list reason))))

===Asynchronous===

(let* ((method 'get)

(url '"http://lfe.github.io")

((tuple 'http (tuple request-id result))

(: io format '"Result: ~p~n" (list result))))))

=={{header|Liberty BASIC}}==

Uses a dll call and a timer to allow time to receive the file.

result = DownloadToFile( "http://rosettacode.org/wiki/Main_Page", "in.html")

timer 2000, [on]

close #url

end function

=={{header|Lingo}}==

Parent script "SimpleHttpGet":

property _cbHandler

property _cbTarget

call(me._cbHandler, me._cbTarget, res, err)

end if

In some movie script:

--

----------------------------------------

put "Network Error:" && err

end if

Executed in the "Message Window" (=Director's interactive Lingo console):

-- "<!doctype html>

=={{header|LiveCode}}==

Without a callback handler the get URL method will block until complete

get URL "http://httpbin.org/html"

Non-blocking version

answer "Download Complete" with "Okay"

end myUrlDownloadFinished

command getWebResource

load URL "http://httpbin.org/html" with message "myUrlDownloadFinished"

=={{header|LSL}}==

To test it yourself; rez a box on the ground, and add the following as a New Script.

key kHttpRequestId;

default {

}

}

Output:

<pre>Status=200

=={{header|Lua}}==

{{libheader|LuaSocket}}

local http = require("socket.http")

local url = require("socket.url")

local page = http.request('http://www.google.com/m/search?q=' .. url.escape("lua"))

print(page)

=={{header|M2000 Interpreter}}==

(some of them as read only)

Module CheckIt {

Declare xml "Microsoft.XMLHTTP"

}

CheckIt

=={{header|Maple}}==

In Maple 18 or later:

content := URL:-Get( "http://www.google.com/" );

In Maple 17 or earlier:

content := HTTP:-Get( "http://www.google.com/" );

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Print[Import["http://www.google.com/webhp?complete=1&hl=en", "Source"]]

=={{header|MATLAB}} / {{header|Octave}}==

In this example we initiate an HTTP request for a single random number from [http://www.random.org random.org]:

>> random = urlread('http://www.random.org/integers/?num=1&min=1&max=100&col=1&base=10&format=plain&rnd=new')

61

It is possible to make more complicated requests, specifically "GET" and "POST," which is explained in the [http://www.mathworks.com/help/matlab/ref/urlread.html documentation].

=={{header|Nanoquery}}==

import url

response = client.get(url.getFile())

=={{header|Nemerle}}==

using System.Console;

using System.Net;

myStream.Close()

}

=={{header|NetRexx}}==

An implementation of the [[#Java|Java]] version shown above; demonstrating NetRexx's ability to exploit the rich Java SDK.

options replace format comments java crossref symbols binary

end

=={{header|NewLisp}}==

(get-url "http://www.rosettacode.org")

=={{header|Nim}}==

var client = newHttpClient()

=={{header|Objeck}}==

use Collection;

};

}

=={{header|Objective-C}}==

int main (int argc, const char * argv[]) {

}

return 0;

=={{header|OCaml}}==

let () =

let url = "http://www.rosettacode.org" in

print_endline page_content;

;;

The source code of the function ''make_request'' is [[Web_Scraping/OCaml|here]].

{{libheader|libcurl}}

(import (lib curl))

(curl 'url "http://rosettacode.org/")

(curl 'perform)

=={{header|ooRexx}}==

Got this from a friend. Needs bsf4oorexx from sourceforge.

<br>Note that rosettacode.org (as used by java and NetRexx) does not permit this access!

sc =.bsf~new("java.util.Scanner",url~openStream)

loop while sc~hasNext

say sc~nextLine

End

{{out}}

massaged to avoid problems.

=={{header|Oz}}==

When creating a file object, it is possible to specify an URL instead of a filename:

declare

fun {GetPage Url}

in

{System.showInfo {GetPage "http://www.rosettacode.org"}}

{{libheader|OzHttpClient}}

If you need more fine-grained control of the request, you could use a custom library:

declare

[HTTPClient] = {Module.link ['x-ozlib://mesaros/net/HTTPClient.ozf']}

in

{System.showInfo {GetPage "http://www.rosettacode.org"}}

=={{header|Pascal}}==

{{works with|Free Pascal}}

Using [http://wiki.freepascal.org/fphttpclient fphttpclient]

uses fphttpclient;

end;

writeln(s)

{{works with|Free Pascal}} {{libheader|CThreads}} {{libheader|Classes}} {{libheader|httpsend}}

{$mode objfpc}{$H+}

Readln;

=={{header|Peloton}}==

English dialect, short form:

<@ SAYURLLIT>http://rosettacode.org/wiki/Main_Page</@>

English dialect, padded variable-length form:

<# SAY URLSOURCE LITERAL>http://rosettacode.org/wiki/Main_Page</#>

=={{header|Perl}}==

This sample is nearly identical to the LWP sample except that it uses HTTP::Tiny which was added to the core libraries in [[Perl/5.14]].

require 5.014; # check HTTP::Tiny part of core

use HTTP::Tiny;

===Library examples===

Classic LWP sample.

$ua->agent(undef) ; # cloudflare blocks default LWP agent

or with more error-checking

use LWP::UserAgent;

$response->is_success or die "Failed to GET '$url': ", $response->status_line;

=={{header|Phix}}==

{{libheader|Phix/libcurl}}

Note that curl_easy_get_file() is better suited to multi-megabyte downloads than curl_easy_perform_ex().

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins<span style="color: #0000FF;">\<span style="color: #000000;">libcurl<span style="color: #0000FF;">.<span style="color: #000000;">e</span>

<span style="color: #7060A8;">curl_global_init<span style="color: #0000FF;">(<span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #000000;">res<span style="color: #0000FF;">)

{{out}}

<pre>

=={{header|PHP}}==

readfile("http://www.rosettacode.org");

=={{header|PicoLisp}}==

(load "@lib/http.l")

(client "rosettacode.org" 80 NIL # Connect to rosettacode

(out NIL (echo)) ) # Echo to standard output

=={{header|Pike}}==

write("%s",Protocols.HTTP.get_url_data("http://www.rosettacode.org"));

=={{header|PowerShell}}==

$wc = New-Object Net.WebClient

$wc.DownloadString('http://www.rosettacode.org')

=={{header|Prolog}}==

Works with SWI-Prolog and library http/http_open. (Extract from the doc).

:- use_module(library( http/http_open )).

copy_stream_data(In, user_output),

close(In).

=={{header|PureBasic}}==

InitNetwork()

OpenConsole()

DeleteFile(filename$)

EndIf

Another solution using general networking commands

InitNetwork()

OpenConsole()

; next line only to prevent console from closing on Windows

Input()

Of course you could use wget too.

;Python 3:

Using the [http://docs.python.org/py3k/library/urllib.request.html urllib.request] module.

import urllib.request

print(urllib.request.urlopen("http://rosettacode.org").read())

Using a more low-level [https://docs.python.org/3/library/http.client.html http.client] library.

from http.client import HTTPConnection

conn = HTTPConnection("example.com")

result = conn.getresponse()

r1 = result.read() # This retrieves the entire contents.

;Python 2:

Using the [http://docs.python.org/library/urllib.html urllib] library.

import urllib

print urllib.urlopen("http://rosettacode.org").read()

Using the [http://docs.python.org/library/urllib2.html urllib2] library.

import urllib2

print urllib2.urlopen("http://rosettacode.org").read()

{{libheader|Requests}}

{{works with|Python|2.7, 3.4–3.7}}

import requests

print(requests.get("http://rosettacode.org").text)

=={{header|R}}==

First, retrieve the webpage.

library(RCurl)

webpage <- getURL("http://rosettacode.org")

.opts=list(proxy="123.123.123.123", proxyusername="domain\\username", proxypassword="mypassword", proxyport=8080))

#Don't forget that backslashes in your username or password need to be escaped!

Now parse the html code into a tree and print the html.

library(XML)

pagetree <- htmlTreeParse(webpage )

pagetree$children$html

=={{header|Racket}}==

#lang racket

(require net/url)

#:redirections 100)

(current-output-port))

=={{header|Raku}}==