URLPattern: URLPattern() Konstruktor

Syntax

new URLPattern(input)
new URLPattern(input, options)
new URLPattern(url)
new URLPattern(url, baseURL)
new URLPattern(url, baseURL, options)

Parameter

input Optional

Ein Objekt, das separate Eigenschaften zur Definition der Muster hat, die fr jeden Teil einer URL verwendet werden.

Die Objektglieder knnen beliebig (oder gar nicht) sein:

protocol Optional

Ein Muster, das ein URL-Protokoll wie http, https oder "http{s}?" (um sowohl https als auch http zu matchen) erfasst.

username Optional

Ein Muster, das einen URL-Benutzernamen erfasst.

password Optional

Ein Muster, das ein URL-Passwort erfasst.

hostname Optional

Ein Muster, das einen URL-Hostname erfasst.

port Optional

Ein Muster, das einen URL-Port erfasst.

pathname Optional

Ein Muster, das einen URL-Pfadnamen erfasst.

search Optional

Ein Muster, das ein URL-Suche erfasst.

hash Optional

Ein Muster, das ein URL-Hash erfasst.

baseURL Optional

Ein String, der eine absolute URL bereitstellt, von der ungenauere Objekt-Eigenschaften geerbt werden knnen.

url Optional

Ein String, der URL-Muster zur bereinstimmung darstellt.

Dies ist entweder als absolute oder relative URL formatiert, kann jedoch Markup enthalten, um bereinstimmungsmuster und Escape-Sequenzen anzugeben. Wenn es als relative URL formatiert ist, muss baseURL ebenfalls angegeben werden.

baseURL Optional

Ein String, der eine absolute URL bereitstellt, von der nicht festgelegte, weniger spezifische URL-Teile geerbt werden knnen. Dies muss festgelegt werden, wenn url eine relative URL ist und darf nicht festgelegt werden, wenn input verwendet wird (input.baseURL kann verwendet werden, um vererbte Werte fr ein input bereitzustellen, ist aber im Gegensatz zu dieser Eigenschaft nie erforderlich).

options Optional

Ein Objekt, das Optionen zur bereinstimmung des gegebenen Musters bereitstellt. Die zulssigen Objektmitglieder sind:

ignoreCase Optional

Ermglicht die gro-/kleinschreibungsunabhngige bereinstimmung, wenn auf true gesetzt. Wenn weggelassen oder auf false gesetzt, erfolgt die bereinstimmung unter Bercksichtigung der Gro-/Kleinschreibung.

Ausnahmen

TypeError

Gibt eines der folgenden an:

• Das angegebene input, url oder baseURL ist nicht gltig oder syntaktisch korrekt.
• Die angegebene url ist relativ, aber es wird keine baseURL bereitgestellt, um eine vollstndige absolute URL zu bilden.
• Eine baseURL ist angegeben, und input ist ein absolutes Muster oder ein strukturiertes Objekt.

Beschreibung

Der URLPattern Konstruktor kann entweder ein "input"-Objekt oder einen URL-String und optional eine baseURL annehmen. Beide Formen knnen auch ein Optionsobjekt als Argument enthalten, das zustzliche bereinstimmungsoptionen festlegt, wie etwa die Bercksichtigung der Gro-/Kleinschreibung.

new URLPattern(input);
new URLPattern(url, baseURL);

Das im ersten Konstruktionstyp verwendete Eingabeobjekt beschreibt die URLs, die durch die Angabe von Mustern fr einzelne URL-Teile bereinstimmen sollen: protocol, username, password, hostname, port, pathname, search, hash und baseURL. Wenn die baseURL-Eigenschaft angegeben wird, wird sie als URL analysiert und kann verwendet werden, um andere Eigenschaften zu ergnzen, die fehlen (siehe den folgenden Abschnitt Inheritance from a base URL). Eigenschaften, die ausgelassen oder nicht durch die baseURL-Eigenschaft ergnzt werden, standardisieren auf den Platzhalterstring (*), der gegen jeden entsprechenden Wert in einer URL bereinstimmt.

Der zweite Konstruktionstyp nimmt einen URL-String, der Muster eingebettet in ihm enthalten kann. Der String kann eine absolute oder relative URL angeben wenn das Muster relativ ist, muss baseURL als zweites Argument angegeben werden. Beachten Sie, dass es erforderlich sein kann, einige Zeichen zu escapen im URL-String, wenn unklar ist, ob das Zeichen verschiedene URL-Komponenten trennt oder Teil eines Musters ist.

Vererbung von einer Basis-URL

URL-Teile, die spezifischer als der am wenigsten spezifische Teil in der url definiert sind, knnen von baseURL (oder von input.baseURL fr input) geerbt werden. Intuitiv bedeutet dies, dass, wenn der pathname-Teil im Eingabewert angegeben ist, die Teile zur linken Seite in einer URL von der Basis-URL (protocol, hostname und port) geerbt werden knnen, whrend die Teile zur rechten Seite (search und hash) nicht geerbt werden knnen. Der username und das password werden nie von der Basis-URL geerbt.

Fr weitere Informationen siehe Inheritance from a BaseURL im API-berblick.

Hostname in url oder baseURL beeinflusst den Standardport

Im Gegensatz zu anderen URL-Teilen kann der Port implizit gesetzt werden, wenn Sie eine url oder Basis-URL (entweder im baseURL-Parameter oder im Objekt) angeben und keinen Port explizit angeben. In diesem Fall wird der Port auf den leeren String ("") gesetzt und entspricht dem Standardport (443).

Zum Beispiel setzen diese Muster alle den Port auf den leeren String (""):

new URLPattern("https://example.com");
new URLPattern("https://example.com*");
new URLPattern("https://example.com/foo");
new URLPattern({
  pathname: "/foo/*",
  baseURL: "https://example.com",
});

Wenn Sie keinen Hostnamen in einer url oder baseURL angeben, wird der Port standardmig auf den Platzhalterstring (*) gesetzt:

new URLPattern({ pathname: "/foo/*" }); // Port omitted, defaults to '*'

Escaping spezieller Zeichen

Die Mustersyntax enthlt eine Reihe von Zeichen, die natrlich in URLs vorkommen knnen, wie z.B.:

• ? gibt sowohl ein optionales Zeichen oder eine Gruppe in einem Muster an und der Suchteil einer URL.
• : kennzeichnet den Beginn einer benannten Gruppe in einem Muster und einen Trenner fr Benutzername und Passwort oder einen Hostnamen und einen Port.

Wenn Sie einen URLPattern mit dem url Stringparameter konstruieren, werden diese speziellen Zeichen (bei jeglicher Unklarheit) als Teil der Mustersyntax angenommen. Wenn Sie die Zeichen verwenden, um Teile der URL darzustellen, mssen Sie sie escapen, indem sie ihnen \\ voranstellen (oder das Problem vermeiden, indem Sie URLPattern mit der Objektsyntax konstruieren).

Zum Beispiel entkommt das folgende Muster dem ?-Zeichen, was dieses Muster dazu bringt, einen search URL-Teil von "fred" zu erfassen:

console.log(new URLPattern("https://example.com/*\\?fred"));

Ebenso zeigt das unten stehende Match the username and password Beispiel einen Fall, in dem der : Trenner escaped werden muss.

Beispiele

Standardmuster

Dieser Code zeigt, dass URL-Teile, die in einer URL oder von einer Basis-URL geerbt werden, nicht angegeben sind, standardmig den Platzhalterwert verwenden.

console.log(new URLPattern());
console.log(new URLPattern({}));
/*
{
  protocol: "*",
  username: "*",
  password: "*",
  hostname: "*",
  port: "*",
  pathname: "*",
  search: "*",
  hash: "*",
  hasRegExpGroups: false,
};
*/

Ein pathname abgleichen

let pattern1 = new URLPattern("https://example.com/books/:id");

// same as
let pattern2 = new URLPattern("/books/:id", "https://example.com");

// or
let pattern3 = new URLPattern({
  protocol: "https",
  hostname: "example.com",
  pathname: "/books/:id",
});

// or
let pattern4 = new URLPattern({
  pathname: "/books/:id",
  baseURL: "https://example.com",
});

// or
let pattern5 = new URLPattern({
  pathname: "/books/:id",
  baseURL: "https://example.com/some/path/?search=3#param=1",
  // More-specific URL parts are discarded
});

Das Protokoll und den Hostnamen abgleichen

let pattern = new URLPattern({
  protocol: "http{s}?",
  hostname: ":subdomain.example.com",
});

Den Benutzernamen und das Passwort abgleichen

Dies setzt die Benutzername- und Passwort-URL-Teile mit dem Musterstring. Beachten Sie, wie der : Trenner escaped werden muss, wenn der Musterstring verwendet wird. Ohne dieses wre das Benutzernamenmuster myusername:mypassword.

const pattern = new URLPattern(
  "https://myusername\\:mypassword@example.com/some/path",
);

console.log(pattern.username); // "myusername"
console.log(pattern.password); // "mypassword"

Aus diesem Grund ist es oft natrlicher (und sicherer), die Objektsyntax zu verwenden.

Alle mglichen strukturierten Teile abgleichen

let pattern = new URLPattern({
  protocol: "http{s}?",
  username: ":username",
  password: ":password",
  hostname: ":subdomain.example.com",
  port: ":port(80|443)",
  pathname: "/:path",
  search: "*",
  hash: "*",
});

Gro-/Kleinschreibung ignorierende bereinstimmung

// Case-sensitive matching by default
const pattern = new URLPattern("https://example.com/2022/feb/*");
console.log(pattern.test("https://example.com/2022/feb/xc44rsz")); // true
console.log(pattern.test("https://example.com/2022/Feb/xc44rsz")); // false

Das Setzen der ignoreCase-Option auf true im Konstruktor schaltet alle bereinstimmungsoperationen auf Gro-/Kleinschreibung ignorierend fr das gegebene Muster:

// Case-insensitive matching
const pattern = new URLPattern("https://example.com/2022/feb/*", {
  ignoreCase: true,
});
console.log(pattern.test("https://example.com/2022/feb/xc44rsz")); // true
console.log(pattern.test("https://example.com/2022/Feb/xc44rsz")); // true

Vererbung von der Basis-URL

Dies bietet ein reales Beispiel der Vererbung. Das pathname ist explizit angegeben. Die Werte, die weniger spezifisch als das pathname sind, wie das Protokoll und der Hostname, werden geerbt. Die spezifischeren Werte werden ignoriert und setzen auf ihre Standardwerte (wie "*" fr die Suche und das Hash, und "" fr den Port).

const pattern = new URLPattern({
  pathname: "/some/path",
  baseURL: "https://myuser:mypass@example.com/mypath?search=1&p=3#fred",
});

console.log(pattern);
// protocol: https
// username: *
// password: *
// hostname: example.com
// port:
// pathname: /some/path
// search: *
// hash: *

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Ein Polyfill von URLPattern ist verfgbar auf GitHub