Making HTTP Requests in Various Programming Languages

JavaScript

JavaScript, primarily used for web development, offers several ways to make HTTP requests. One of the most common methods is using the Fetch API.

Using Fetch API

fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));

Node.js

Node.js, being a server-side runtime environment, has multiple libraries to handle HTTP requests. One of the popular libraries is Axios.

Using Axios

const axios = require('axios');

axios.get('https://api.example.com/data')
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error('Error:', error);
    });

C++

In C++, making HTTP requests can be achieved using libraries such as libcurl.

Using libcurl

#include <curl/curl.h>
#include <iostream>

int main() {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://api.example.com/data");
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    return 0;
}

Python

Python simplifies HTTP requests with the help of the Requests library.

Using Requests

import requests

response = requests.get('https://api.example.com/data')
if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print('Error:', response.status_code)
    

PHP

In PHP, you can make HTTP requests using the cURL library.

Using cURL

<?php
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://api.example.com/data");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

$output = curl_exec($ch);
if ($output === FALSE) {
    echo 'cURL Error: ' . curl_error($ch);
} else {
    $data = json_decode($output, true);
    print_r($data);
}

curl_close($ch);
?>

Ruby

Ruby can handle HTTP requests using the Net::HTTP library.

Using Net::HTTP

require 'net/http'
require 'json'

url = URI('https://api.example.com/data')
response = Net::HTTP.get(url)
data = JSON.parse(response)
puts data

Java

In Java, you can use the HttpURLConnection class to make HTTP requests.

Using HttpURLConnection

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpRequestExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.example.com/data");
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setRequestMethod("GET");

            int status = con.getResponseCode();
            if (status == 200) {
                BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String inputLine;
                StringBuilder content = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
                in.close();
                System.out.println(content.toString());
            } else {
                System.out.println("Error: " + status);
            }
            con.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Go

Go, with its standard library, makes it straightforward to perform HTTP requests using the net/http package.

Using net/http

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("https://api.example.com/data")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Println("Error reading body:", err)
            return
        }
        fmt.Println(string(body))
    } else {
        fmt.Println("Error: Status Code", resp.StatusCode)
    }
}

Android Studio (Java)

In Android development, making HTTP requests can be done using libraries such as OkHttp.

Using OkHttp

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class HttpRequestExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
            .url("https://api.example.com/data")
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                System.out.println(response.body().string());
            } else {
                System.out.println("Error: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
    

Swift (iOS)

For iOS development, you can use the URLSession class to make HTTP requests.

Using URLSession

import Foundation

let url = URL(string: "https://api.example.com/data")!

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Error:", error)
        return
    }
    guard let data = data else {
        print("No data")
        return
    }
    if let jsonString = String(data: data, encoding: .utf8) {
        print(jsonString)
    }
}

task.resume()

Perl

Perl can handle HTTP requests using the LWP::UserAgent module.

Using LWP::UserAgent

use strict;
use warnings;
use LWP::UserAgent;
use JSON;

my $ua = LWP::UserAgent->new;
my $response = $ua->get('https://api.example.com/data');

if ($response->is_success) {
    my $data = decode_json($response->decoded_content);
    print "$data\n";
} else {
    die $response->status_line;
}

Rust

In Rust, you can use the reqwest crate to make HTTP requests.

Using reqwest

use reqwest::blocking::get;
use std::error::Error;

fn main() -> Result<(), Box> {
    let response = get("https://api.example.com/data")?.text()?;
    println!("{}", response);
    Ok(())
}

Kotlin

Kotlin, often used for Android development, can utilize the OkHttp library for making HTTP requests.

Using OkHttp

import okhttp3.OkHttpClient
import okhttp3.Request

fun main() {
    val client = OkHttpClient()

    val request = Request.Builder()
        .url("https://api.example.com/data")
        .build()

    client.newCall(request).execute().use { response ->
        if (response.isSuccessful) {
            response.body?.string()?.let {
                println(it)
            }
        } else {
            println("Error: ${response.code}")
        }
    }
}

Conclusion

Making HTTP requests is a fundamental task in programming, and each language offers its own libraries and methods to handle these requests efficiently. From JavaScript's Fetch API to Python's Requests library, and Java's HttpURLConnection, each approach provides a unique way to interact with web services. Understanding these various methods can enhance your ability to work across different programming environments and build more versatile applications.