Kurrikulum Leson 33 van 156 · HTTP van binne af
HTTP van binne af

Parse 'n rou HTTP-aanvraag

Waarom dit saak maak Elke bladsy wat jy laai begin as 'n kort stuk teks wat jou browser na 'n bediener stuur, en daardie teks is waar die meeste spooropvolgingsinligting beweeg: jou cookies, die bladsy van waar jy gekom het, jou taal. Sodra jy dit kan lees, is niks daarvan vir jou wegstek nie, en elke hulpmiddel in hierdie gedeelte (die tracker, die blocker, die measurements) is daarop gebou.

Dink aan 'n HTTP request as 'n brief in 'n baie streng formaat. Die eerste lyn sê wat jy wil hê, dan kom daar genommer notas op die koever, dan 'n leë lyn, dan (soms) die inhoud. 'n Response is die antwoordbrief, in dieselfde formaat. Jou browser skryf en lees duisende van hierdie per dag.

HTTP: HyperText Transfer Protocol, die ooreengekomde formaat wat blousers en bedieners gebruik om bladsye, prente en data aan te vra en te stuur.

Request: die boodskap wat die blutsender stuur: 'n method (wat om te doen, soos GET om te haal of POST om 'n vorm te stuur), 'n target (watter pad op die bediener) en 'n version.

Header: een gelabelde nota in die boodskap, geskryf Name: value op sy eie lyn, soos Accept-Language: en-GB.

Hoe 'n rou versoek lyk

Hier is 'n versoek wat die oefen-blaaier gestuur het vir ShopA se tent-bladsy. Elke reël eindig in twee onsigbare karakters, carriage return en line feed, wat in Python as \r\n geskryf word. 'n Leë reël (so \r\n\r\n in 'n ry) merk die einde van die kop.

GET /p/tent HTTP/1.1
Host: shopa.example
User-Agent: PracticeBrowser/1.0 (Linux) Practice Firefox 144
Accept-Language: en-ZA
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
  • Aansoeklyn: GET /p/tent HTTP/1.1, drie dele geskei deur enkel spasies.
  • Headers: een per reël, die naam, 'n dubbelpunt, dan die waarde.
  • Blanke lyn: die kop is oor.
  • Body: wat volg. 'n GET het gewoonlik niks nie; 'n vorm POST bevat die vormvelde, soos user=sam.

A se antwoord het dieselfde vorm, maar sy eerste lyn is 'n status lyn: HTTP/1.1 200 OK. Die middeldeel is die status kode (200 beteken goed, 302 beteken "gaan elders", 404 beteken "nie gevind nie") en die res is die rede frase, 'n menslike etiket wat spasies kan bevat (Moved Permanently) of heeltemal kan ontbreek.

Statuskode: 'n drie-syferige getal aan die begin van 'n respons wat sê hoe dinge verloop het. 2xx sukses, 3xx weerlei, 4xx 'n probleem met die versoek, 5xx 'n probleem op die bediener.

Drie Python-gereedskap wat jy nodig het

text.partition(sep) splits by die first sep en gee drie dele terug: before, die separator, after. text.split(sep, 2) splits hoogstens twee keer, so 'n reason-frase met spasies bly in een stuk. text.strip() verwyder spasies van beide kante.

"Referer: https://shopa.example/".partition(":")
# ('Referer', ':', ' https://shopa.example/')
"HTTP/1.1 301 Moved Permanently".split(" ", 2)
# ['HTTP/1.1', '301', 'Moved Permanently']

A algemene fout

Split 'n header-reël by elke elke kolon. Referer: https://shopa.example/ het 'n kolon binne sy waarde, so line.split(":") sny die adres in twee. Splits altyd net by die eerste kolon. Ware blousers het dit die harde manier geleer: slordige parsers is 'n klassieke bron van sekuriteitsfoute, waar twee programme dieselfde boodskap anders lees.

Lyk Die regte web lyk nog steeds so?

Befoklik is dit. Blousers praat vandag gewoonlik HTTP/2 of HTTP/3, wat dieselfde methods, headers en bodies in binêre frames stuur in plaas van teksreëls. DevTools wys dit vir jou as teks, so die velde wat jy hier leer is presies die een wat jy daar sal sien (nasien Oktober 2026). Die praktykwereld skryf alles as HTTP/1.1 teks, wat steeds is wat baie bedieners en gereedskap gebruik.

Probeer dit Maak DevTools oop (F12, of Cmd+Option+I op 'n Mac), kies die Network-tab en laai enige bladsyde nuut. Klik op die eerste versoek en kyk na Request Headers. Baie blousers bied 'n "Raw" skakelaar wat die kop presies in hierdie formaat wys.

In ander tale

JavaScript:

function parseRequest(raw) {
  const [head, ...rest] = raw.split("\r\n\r\n");
  const lines = head.split("\r\n");
  const [method, target, version] = lines[0].split(" ");
  const headers = lines.slice(1).map(line => {
    const i = line.indexOf(":");            // first colon only
    return [line.slice(0, i).trim(), line.slice(i + 1).trim()];
  });
  return { method, target, version, headers, body: rest.join("\r\n\r\n") };
}

Go:

// the standard library has a real parser: net/http.ReadRequest
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(raw)))
if err == nil {
    fmt.Println(req.Method, req.URL.Path, req.Header.Get("User-Agent"))
}

Rust:

let (head, body) = raw.split_once("\r\n\r\n").unwrap_or((raw, ""));
let mut lines = head.split("\r\n");
let mut first = lines.next().unwrap().splitn(3, ' ');
let (method, target) = (first.next(), first.next());
let headers: Vec<(&str, &str)> = lines
    .filter_map(|l| l.split_once(':'))
    .map(|(n, v)| (n.trim(), v.trim()))
    .collect();

Opsomming

  • A is 'n versoeklyn, koppe, 'n leë lyn, en dan 'n opsionele liggaam; 'n antwoord begin met 'n statuslyn in plaas daarvan.
  • Skei die kop van die liggaam by die eerste \r\n\r\n, en elke kop by sy eerste dubbelpunt.
  • Die rede-frase kan spasies bevat of weggelaat word, so verdeel die statuslyn hoogstens twee keer.
  • HTTP/2 en HTTP/3 dra dieselfde velde in binêre, so hierdie prentjie hou steeds.
Jou beurt

Skryf parse_request(raw) wat 'n dict teruggee met "method", "target" (pad plus query), "version", "headers" ( 'n lys van (name, value)-paare in volgorde, geskei by die eerste kolon, albei gestrip) en "body" (alles na die eerste leë lyn, "" as daar geen is). Skryf dan parse_response(raw) wat "version", "status" ( 'n int), "reason" ("" as dit ontbreek), "headers" en "body" op dieselfde manier teruggee.

Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les

Hierdie oefening open binnekort

Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.