HTTP: Difference between revisions

 

;Task:

 

There is a separate task for [[HTTPS Request]]s.

 

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

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

 

=={{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|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|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++}}==

#include <winsock2.h>

#include <ws2tcpip.h>

return 0;

}

 

{{libheader|U++}}

 

#include <Web/Web.h>

 

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

}

 

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

USER>Do HttpRequest.HttpResponse.Data.OutputToDevice()

</pre>

 

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

 

=={{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|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}}==

 

 

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

 

=={{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|Haskell}}==

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

 

import Network.Browser

import Network.HTTP

import Network.URI

 

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

 

public class Main {

}

 

{{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}}==

req.onload = function() {

console.log(this.responseText);

 

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

 

Using jQuery:

 

console.log(data);

 

=={{header|Julia}}==

 

 

=={{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|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|MIRC Scripting Language}}==

See [[HTTP/MIRC Scripting Language]]

 

=={{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}}==

 

 

=={{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]].

 

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

<pre><-!DOCTYPE HTML-

..

=={{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}}==

 

{$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|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()

 

=={{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|REALbasic}}==

REALBasic provides an HTTPSocket class for handling HTTP connections. The 'Get' method of the HTTPSocket is overloaded and can download data to a file or return data as a string, in both cases a timeout argument can be passed.

Dim sock As New HTTPSocket

Print(sock.Get("http://www.rosettacode.org", 10)) //set the timeout period to 10 seconds.

 

=={{header|REBOL}}==

print read http://rosettacode.org

 

=={{header|REXX}}==

This script takes an URL as an argument and displays the content on the terminal. It uses the external program `curl` to perform both the acquisition of the data and the display.

 

/* GET2.RX - Display contents of an URL on the terminal. */

/* Usage: rexx get.rx http://rosettacode.org */

parse arg url .

 

A simple change to the script will redirect the output to an internal variable for internal processing. (Our "internal processing" in this case is to display it.)

 

/* GET2.RX - Display contents of an URL on the terminal. */

/* Usage: rexx get2.rx http://rosettacode.org */

do i = 1 to stuff.0

say stuff.i

 

Another simple change redirects the output to another external program like a shell pipe.

 

/* GET3.RX - Display contents of an URL on the terminal. */

/* Usage: rexx get3.rx http://rosettacode.org */

parse arg url .

address system 'curl' url with output fifo ''

 

=={{header|RLaB}}==

Yahoo [http://ichart.finance.yahoo.com/table.csv?s=PFE&a=00&b=4&c=1982&d=00&e=10&f=2010&g=d&ignore=.csv].

 

// get cvs data from Yahoo for Pfeizer (PFE)

url="http://ichart.finance.yahoo.com/table.csv?s=PFE&a=00&b=4&c=1982&d=00&e=10&f=2010&g=d&ignore=.csv";

x = readm(url);

close (url);

 

=={{header|Ruby}}==

The simple way loads the entire content into memory, then prints it.

 

require 'open-uri'

 

print open("http://rosettacode.org") {|f| f.read}

 

If the content might be large, the better way uses FileUtils.copy_stream.

 

require 'fileutils'

require 'open-uri'

 

open("http://rosettacode.org/") {|f| FileUtils.copy_stream(f, $stdout)}

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

Cargo.toml

[dependencies]

hyper = "0.6"

src/main.rs

//cargo-deps: hyper="0.6"

// The above line can be used with cargo-script which makes cargo's dependency handling more convenient for small programs

println!("{}", body);

}

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object HttpTest extends App {

 

Source.fromURL("http://www.rosettacode.org").getLines.foreach(println)

 

=={{header|Scheme}}==

{{works with|Guile}}

 

; Use the regular expression module to parse the url (included with Guile)

(use-modules (ice-9 regex))

(do ((c (read-char s) (read-char s))) ((eof-object? c))

(display c)))

{{works with|Chicken Scheme}}

Using the [http://api.call-cc.org/doc/http-client http-client] library, this is trivial.

(use http-client)

(print

(with-input-from-request "http://google.com/"

#f read-string))

 

=={{header|Seed7}}==

which gets data specified by an URL using the HTTP protocol.

 

$ include "seed7_05.s7i";

include "gethttp.s7i";

begin

writeln(getHttp("www.rosettacode.org"));

 

=={{header|Sidef}}==

Sidef can load and use Perl modules:

}

 

 

=={{header|SNOBOL4}}==

{{works with|Macro SNOBOL4 in C}}

tcp.open(.conn,'www.rosettacode.org','http') :s(cont1)

terminal = "cannot open" :(end)

tcp.close(.conn)

end

 

=={{header|Swift}}==

 

let request = NSURLRequest(URL: NSURL(string: "http://rosettacode.org/")!)

}

 

 

=={{header|Tcl}}==

Note that the <code>http</code> package is distributed as part of Tcl.

 

package require http

set request [http::geturl "http://www.rosettacode.org"]

puts [http::data $request]

=={{header|TSE SAL}}==

 

DLL "<urlmon.dll>"

END

 

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

SET DATEN = REQUEST ("http://www.rosettacode.org")

*{daten}

 

=={{header|UNIX Shell}}==

 

 

 

 

{{works with|BSD}}

 

=={{header|VBScript}}==

 

Based on code at [http://itknowledgeexchange.techtarget.com/vbscript-systems-administrator/how-to-retrieve-html-web-pages-with-vbscript-via-the-microsoftxmlhttp-object/ How to retrieve HTML web pages with VBScript via the Microsoft.XmlHttp object]

Option Explicit

 

 

Set oHTTP = Nothing

 

=={{header|Visual Basic .NET}}==

Imports System.Net

 

Dim content As String = client.DownloadString("http://www.google.com")

Console.WriteLine(content)

 

=={{header|zkl}}==

File htmlGet.zkl. This uses HTTP/1.0 Protocol to avoid chunked data. Or use cURL (see https example).

 

host := url;

server.write(get);

data := server.read(True);

zkl htmlGet.zkl rosettacode.org/wiki/HTTP

{{out}}

...

</pre>

 

=={{header|Zsh}}==

zmodload zsh/net/tcp

ztcp example.com 80

while read -u $fd -r -e -t 1; do; :; done

ztcp -c $fd

 

{{omit from|Applesoft BASIC|No TCP/IP network support on Apple II}}

{{omit from|Brainf***}}

{{omit from|Inform 7|Does not have network access.}}

{{omit from|Integer BASIC|No TCP/IP network support on Apple II}}

{{omit from|PostScript}}

{{omit from|Retro|Does not have network access.}}

{{omit from|TI-83 BASIC|Does not have network access.}}

{{omit from|TI-89 BASIC|Does not have network access.}}

{{omit from|Yorick|Does not have network access.}}

{{omit from|ZX Spectrum Basic|Does not have network access.}}