Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision. Weiterlesen.

URLs (Uniform Resource Locators) sind eine der kritischsten Infrastrukturen des Internets. Beim Erstellen von Webanwendungen müssen Sie URLs manipulieren, um Ressourcen zu lokalisieren und abzurufen.

Wenn Sie anspruchsvollere Web-Apps erstellen, müssen Sie mit URLs auf einer feinkörnigeren Ebene arbeiten. Möglicherweise müssen Sie das Schema, den Hostnamen, den Pfad und die Abfrageparameter identifizieren. Sie müssen auch wissen, wie URLs codiert und decodiert werden, damit Sie mit Sonderzeichen umgehen und Ihre Webanwendung sicher halten können.

Die Standardbibliothek von Go stellt das net/url-Paket bereit, um URLs und URL-Komponenten zu verarbeiten.

Das URL-Paket

Der URL Paket bietet umfassende Funktionen und Features für die Arbeit mit URLs und ihre separaten Teile. Es bietet Funktionen zum Analysieren, Erstellen, Codieren und Decodieren von URLs, wodurch das Paket für die Webentwicklung nützlich ist.

instagram viewer

Einige der Hauptmerkmale des URL Paket sind die Möglichkeit, URLs in einzelne Komponenten zur Bearbeitung und URL-Konstruktion für HTTP-Anforderungen zu zerlegen. Der URL Paket bietet auch a URL Struktur mit a Analysieren Methode zum Parsen von Zeichenfolgen in URLs.

Hier ist die URL. URL Strukturmodell:

Paket hauptsächlich
Typ URL Struktur {
// Scheme ist das Protokollschema der URL,
// wie "http" oder "https"
 Planen Schnur


// Opaque wird verwendet, um alle undurchsichtigen Daten zu speichern
// die in der URL kodiert werden sollte
 Undurchsichtig Schnur


// Der Benutzer enthält Informationen über den Benutzer, der die Anfrage gestellt hat,
// wie Benutzername und Passwort
 Benutzer *Benutzerinfo


// Host ist der Hostname oder die IP-Adresse
// des Servers, der die URL hostet
 Gastgeber Schnur


// Pfad ist der Pfad der URL auf dem Server
 Weg Schnur


// RawPath ist das Original,
// codierter Pfad der URL
 RawPath Schnur


// ForceQuery gibt an, ob die URL eine Abfragezeichenfolge enthalten soll
// auch wenn es leer ist
 Abfrage erzwingen bool


// RawQuery ist das Original,
//codierter Abfragestring der URL
 RawQuery Schnur


// Fragment ist die Fragmentkennung der URL, 
// Wird verwendet, um auf ein bestimmtes Element auf einer Seite zu verlinken
 Fragment Schnur
// RawFragment ist das Original,
// codierter Fragmentbezeichner der URL
 RawFragment Schnur
}

Zu wissen, wie man auf verschiedene Teile der URL struct kann für Aufgaben wie die Validierung nützlich sein.

Parsen von URLs mit der Parse-Funktion

Der Analysieren Funktion der URL -Paket bietet die Funktionalität zum Parsen von URL-Zeichenfolgen in einzelne Komponenten. Der Analysieren -Funktion nimmt eine einzelne URL als Argument und gibt einen Zeiger auf die zurück URL. URL struct, das die geparsten Daten der URL und einen Fehlertyp enthält.

So können Sie die verwenden Analysieren Funktion zum Abrufen der Elemente einer URL.

importieren (
"fmt"
"net/url"
)
Funkhauptsächlich() {
// Die URL, die Sie parsen möchten
 Beispiel-URL := " https://www.example.com/path? param1=wert1&param2=wert2"


// Analysieren Sie die URL
 parsedURL, err := URL. Parsen (Beispiel-URL)


Wenn äh != Null {
 fmt. Println (err)
zurückkehren
 }
// Alle Felder der URL drucken
 fmt. Println("Planen:", parsedURL.Schema)
 fmt. Println("Undurchsichtig:", parsedURL.Undurchsichtig)
 fmt. Println("Benutzer:", parsedURL.Benutzer)
 fmt. Println("Gastgeber:", parsedURL.Host)
 fmt. Println("Weg:", parsedURL.Pfad)
 fmt. Println("RawPath:", parsedURL.RawPath)
 fmt. Println("Abfrage erzwingen:", parsedURL.ForceQuery)
 fmt. Println("RawQuery:", parsedURL.RawQuery)
 fmt. Println("Fragment:", parsedURL.Fragment)
 fmt. Println("RohFragment:", parsedURL.RawFragment)
}

Der Beispiel-URL Variable enthält die vollständige, nicht geparste URL und die Analysieren Funktion analysiert den Inhalt der Beispiel-URL -Variable und gibt die geparste URL zurück. Das Programm endet mit einer Reihe von Aufrufen an Druckln die einzelnen Bereiche der zu demonstrieren URL Struktur.

Die Parse-Funktion überprüft nicht, ob eine URL echt ist und tatsächlich existiert, sie parst die URL nur syntaktisch. Du kannst den... benutzen http Paket um eine GET-Anfrage an die URL zu stellen und die Antwort zu prüfen:

importieren (
"fmt"
"net/http"
)
Funkhauptsächlich() {
// Die URL, die Sie überprüfen möchten
 Beispiel-URL := " https://www.example.com"


// Stellen Sie eine HTTP GET-Anfrage an die URL
 Antwort, ähm := http. Holen Sie sich (Beispiel-URL)


Wenn äh != Null {
 fmt. Println (err)
zurückkehren
 }
verschieben Antwort. Körper. Schließen()

// Überprüfen Sie den Statuscode der Antwort
Wenn Antwort. Statuscode == http. StatusOK {
 fmt. Println("URL existiert.")
 } anders {
 fmt. Println("URL existiert nicht.")
 }
}

Der hauptsächlich Funktion macht a ERHALTEN Anfrage an die Beispiel-URL Verwendung der Erhalten Funktion der http Paket. Diese Funktion gibt eine Antwortinstanz und einen Fehlertyp zurück. Das Programm endet mit einem Wenn Erklärung, um die Existenz der Website zu validieren, indem Sie die überprüfen HTTP-Statuscode gegen das StatusOk konstant von der http Paket.

Dieser Ansatz ermöglicht es Ihnen, basierend auf dem Ergebnis der Prüfung Maßnahmen zu ergreifen, z. B. das Umleiten der Benutzer zu einer anderen Seite, Anzeige einer Fehlermeldung oder Wiederholung der Anfrage nach einer bestimmten Zeit Zeitraum.

Codieren und Decodieren von URL-Parametern

Der URL Paket bietet die Kodieren Methode zum Codieren von URL-Parametern. Der Kodieren Die Funktion codiert Sonderzeichen und Leerzeichen in URL-Parametern in Prozent.

importieren (
"fmt"
"net/url"
)
Funkhauptsächlich() {
// eine neue URL erstellen. Wertestruktur
 Parameter := URL. Werte{}


// Werte zur Struktur hinzufügen
 Parameter. Hinzufügen("Name", "John Smith")
 Parameter. Hinzufügen("Alter", "30")
 Parameter. Hinzufügen("Geschlecht", "männlich")


// codiere die Struktur in einen String
 kodierteParams := Parameter. Kodieren()
 fmt. Println (encodedParams)
// Ausgabe: "Alter=30&Geschlecht=männlich&Name=John+Smith"
}

Der hauptsächlich Funktion erstellt eine neue Werte struct Instanz von URL Paket und die Hinzufügen -Methode der Strukturinstanz fügt der Strukturinstanz Schlüssel-Wert-Paare von Daten hinzu.

Der Kodieren -Methode konvertiert das Schlüssel-Wert-Paar in das URL-Zeichenfolgenformat "Schlüssel1=Wert1&Schlüssel2=Wert2&Schlüssel3=Wert3".

Sie können einen verschlüsselten URL-String mit decodieren ParseQuery Funktion der URL Paket.

importieren (
"fmt"
"net/url"
)
Funkhauptsächlich() {
// codierter String von URL-Parametern
 codierte Parameter := "Alter=30&Geschlecht=männlich&Name=John+Smith"


// den codierten String in eine URL parsen. Wertestruktur
 Parameter, Fehler := URL. ParseQuery (encodedParams)


Wenn äh != Null {
 fmt. Println (err)
 }


// Struktur drucken
 fmt. Println (Parameter)


// Ausgabe: Karte[Alter:[30] Geschlecht:[männlich] Name:[John Smith]]
}

Der kodierterParameter Variable ist eine codierte URL-Zeichenfolge. Der ParseQuery Funktion übernimmt die kodierterParameter -Variable und gibt die decodierte URL-Zeichenfolge und einen Fehler zurück.

Diese Go-Pakete können Ihr Web-Routing-Spiel auf die nächste Stufe bringen

Die URLs, die Sie für die Seiten Ihrer Webanwendung verwenden, tragen zu ihrer Leistung und Sichtbarkeit in Suchmaschinen bei. Web-Routing ist der Prozess, bei dem eingehende Anforderungen basierend auf der URL an die entsprechende Handler-Funktion geleitet werden.

Sie können mit dem http-Paket oder beliebten Paketen von Drittanbietern wie Gorilla Mux, Chi, Pat oder Httprouter routen. Diese Pakete machen das Routing einfacher als das http-Paket, indem sie einige seiner Komplexitäten abstrahieren.