Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission. Læs mere.

URL'er (Uniform Resource Locators) er en af ​​internettets mest kritiske dele af infrastrukturen. Når du bygger webapplikationer, bliver du nødt til at manipulere URL'er for at finde og hente ressourcer.

Når du bygger mere sofistikerede webapps, skal du arbejde med URL'er på et mere detaljeret niveau. Du skal muligvis identificere skemaet, værtsnavnet, stien og forespørgselsparametrene. Du skal også vide, hvordan du koder og afkoder URL'er, så du kan håndtere specialtegn og holde din webapplikation sikker.

Go's standardbibliotek leverer net/url-pakken til at håndtere URL'er og URL-komponenter.

URL-pakken

Det url pakken indeholder omfattende funktioner og funktioner til at arbejde med URL'er og deres separate dele. Det giver funktioner til at parse, konstruere, indkode og afkode URL'er, hvilket gør pakken nyttig til webudvikling.

Nogle af de vigtigste funktioner i

instagram viewer
url pakke er evnen til at parse URL'er til individuelle komponenter til manipulation og URL-konstruktion for HTTP-anmodninger. Det url pakken giver også en URL struktur med en Parse metode til at parse strenge til URL'er.

Her er url. URL struct model:

pakke vigtigste
type URL struktur {
// Scheme er protokolskemaet for URL'en,
// såsom "http" eller "https"
 Ordning snor


// Opaque bruges til at opbevare uigennemsigtige data
// som skal være kodet i URL'en
 Uigennemsigtig snor


// Brugeren har oplysninger om den bruger, der fremsætter anmodningen,
// såsom et brugernavn og adgangskode
 Bruger *Brugerinfo


// Host er værtsnavnet eller IP-adressen
// af serveren, der hoster URL'en
 Vært snor


// Sti er stien til URL'en på serveren
 Sti snor


// RawPath er originalen,
// kodet sti til URL'en
 RawPath snor


// ForceQuery angiver, om URL'en skal indeholde en forespørgselsstreng
// selvom den er tom
 ForceQuery bool


// RawQuery er originalen,
//kodet forespørgselsstreng for URL'en
 RawQuery snor


// Fragment er fragment-id'en for URL'en, 
// bruges til at linke til et bestemt element på en side
 Fragment snor
// RawFragment er originalen,
// kodet fragment-id af URL'en
 RawFragment snor
}

At vide, hvordan man får adgang til forskellige dele af URL struct kan være nyttig til opgaver som validering.

Parsing af URL'er ved hjælp af Parse-funktionen

Det Parse funktion af url pakke giver funktionaliteten til at parse URL-strenge til individuelle komponenter. Det Parse funktion tager en enkelt URL som et argument og returnerer en pointer til url. URL struct, der indeholder de analyserede data for URL'en og en fejltype.

Her er, hvordan du kan bruge Parse funktion til at hente elementerne i en URL.

importere (
"fmt"
"net/url"
)
funcvigtigste() {
// URL'en du vil parse
 eksempelwebadresse := " https://www.example.com/path? param1=værdi1&param2=værdi2"


// Parse URL'en
 parsedURL, fejl := url. Parse (eksempelwebadresse)


hvis fejl!= nul {
 fmt. Println (fejl)
Vend tilbage
 }
// Udskriv alle felterne i URL'en
 fmt. Println("Skema:", parsedURL.Scheme)
 fmt. Println("Uigennemsigtig:", parsedURL.Uigennemsigtig)
 fmt. Println("Bruger:", parsedURL.User)
 fmt. Println("Vært:", parsedURL.Host)
 fmt. Println("Sti:", parsedURL.Path)
 fmt. Println("RawPath:", parsedURL.RawPath)
 fmt. Println("ForceQuery:", parsedURL.ForceQuery)
 fmt. Println("RawQuery:", parsedURL.RawQuery)
 fmt. Println("Fragment:", parsedURL.Fragment)
 fmt. Println("RawFragment:", parsedURL.RawFragment)
}

Det eksempelwebadresse variabel indeholder den fulde, ikke-parserede URL, og Parse funktion analyserer indholdet af eksempelwebadresse variabel og returnerer den parsede URL. Programmet afsluttes med en række opkald til Udskrivln at demonstrere de enkelte felter af URL struktur.

Parsefunktionen kontrollerer ikke, om en URL er en rigtig, der faktisk eksisterer, den analyserer kun URL'en syntaktisk. Du kan bruge http pakke for at lave en GET-anmodning til URL'en og kontrollere svaret:

importere (
"fmt"
"net/http"
)
funcvigtigste() {
// URL'en du vil tjekke
 eksempelwebadresse := " https://www.example.com"


// Lav en HTTP GET-anmodning til URL'en
 svar, fejl := http. Hent (eksempelwebadresse)


hvis fejl!= nul {
 fmt. Println (fejl)
Vend tilbage
 }
udsætte respons. Legeme. Tæt()

// Tjek svarstatuskoden
hvis respons. Statuskode == http. StatusOK {
 fmt. Println("URL findes.")
 } andet {
 fmt. Println("URL findes ikke.")
 }
}

Det vigtigste funktion gør en FÅ anmodning til eksempelwebadresse bruger Få funktion af http pakke. Denne funktion returnerer en svarinstans og fejltype. Programmet afsluttes med en hvis erklæring for at validere webstedets eksistens ved at kontrollere HTTP-statuskode imod StatusOk konstant fra http pakke.

Denne tilgang giver dig mulighed for at foretage handlinger baseret på resultatet af kontrollen, såsom at omdirigere brugeren til en anden side, viser en fejlmeddelelse eller prøver anmodningen igen efter en bestemt periode.

Kodning og afkodning af URL-parametre

Det url pakken giver Indkode metode til kodning af URL-parametre. Det Indkode funktion procent-koder specialtegn og mellemrum i URL-parametre.

importere (
"fmt"
"net/url"
)
funcvigtigste() {
// opret en ny url. Værdier struktur
 params := url. Værdier{}


// tilføje værdier til strukturen
 params. Tilføje("navn", "John Smith")
 params. Tilføje("alder", "30")
 params. Tilføje("køn", "han")


// indkode strukturen til en streng
 encodedParams := params. Encode()
 fmt. Println (encodedParams)
// Output: "age=30&gender=male&name=John+Smith"
}

Det vigtigste funktion opretter en ny Værdier struct forekomst af url pakken, og Tilføje metoden for struct-forekomsten tilføjer nøgleværdi-par af data til struct-forekomsten.

Det Indkode metode konverterer nøgleværdi-parret til URL-strengformatet "nøgle1=værdi1&nøgle2=værdi2&nøgle3=værdi3".

Du kan afkode en kodet URL-streng med ParseQuery funktion af url pakke.

importere (
"fmt"
"net/url"
)
funcvigtigste() {
// kodet streng af URL-parametre
 encodedParams := "alder=30&køn=mand&navn=John+Smith"


// parse den kodede streng til en url. Værdier struktur
 params, fejl := url. ParseQuery (encodedParams)


hvis fejl!= nul {
 fmt. Println (fejl)
 }


// udskriv strukturen
 fmt. Println (parametre)


// Output: kort[alder:[30] køn:[mand] navn:[John Smith]]
}

Det kodet Parameter variabel er en kodet URL-streng. Det ParseQuery funktion tager i kodet Parameter variabel og returnerer den afkodede URL-streng og en fejl.

Disse Go-pakker kan tage dit webrouting-spil til det næste niveau

De URL'er, du bruger til siderne i din webapplikation, bidrager til dens ydeevne og synlighed på søgemaskiner. Web-routing er processen med at dirigere indgående anmodninger til den relevante behandlerfunktion baseret på URL'en.

Du kan rute ved hjælp af http-pakken eller populære tredjepartspakker som Gorilla Mux, Chi, Pat eller Httprouter. Disse pakker gør routing nemmere end http-pakken ved at abstrahere nogle af dens kompleksiteter.