SvelteKitReference

$app/paths

import { asset(alias) function asset(file: Asset): string
import assetResolve the URL of an asset in your static directory, by prefixing it with config.kit.paths.assets if configured, or otherwise by prefixing it with the base path.
During server rendering, the base path is relative and depends on the page currently being rendered.
<script>
	import { asset } from '$app/paths';
</script>

<img alt="a potato" src={asset('/potato.jpg')} />2.26
reference, assets(alias) let assets: "" | `https://${string}` | `http://${string}` | "/_svelte_kit_assets"
import assetsAn absolute path that matches config.kit.paths.assets.

[!NOTE] If a value for config.kit.paths.assets is specified, it will be replaced with '/_svelte_kit_assets' during vite dev or vite preview, since the assets don't yet live at their eventual URL.

Use asset(...) instead
reference, base(alias) let base: "" | `/${string}`
import baseA string that matches config.kit.paths.base.
Example usage: <a href="{base}/your-page">Link</a>
Use resolve(...) instead
reference, match(alias) function match(url: Pathname | URL | (string & {})): Promise<{
    id: RouteId;
    params: Record<string, string>;
} | null>
import matchMatch a path or URL to a route ID and extracts any parameters.
import { match } from '$app/paths';

const route = await match('/blog/hello-world');

if (route?.id === '/blog/[slug]') {
	const slug = route.params.slug;
	const response = await fetch(`/api/posts/${slug}`);
	const post = await response.json();
}2.52.0
reference, resolve(alias) function resolve<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(...args: ResolveArgs<T>): ResolvedPathname
import resolveResolve a pathname by prefixing it with the base path, if any, or resolve a route ID by populating dynamic segments with parameters.
During server rendering, the base path is relative and depends on the page currently being rendered.
import { resolve } from '$app/paths';

// using a pathname
const resolved = resolve(`/blog/hello-world`);

// using a route ID plus parameters
const resolved = resolve('/blog/[slug]', {
	slug: 'hello-world'
});2.26
reference, resolveRoute(alias) function resolveRoute<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(...args: ResolveArgs<T>): ResolvedPathname
import resolveRouteUse resolve(...) instead
reference } from '$app/paths';

asset

Disponible depuis la version 2.26

Résout l’URL d’un asset se trouvant dans votre dossier static, en le préfixant avec config.kit.paths.assets si configuré, ou avec le chemin de base sinon.

Lors du rendu côté serveur, le chemin de base est relatif et dépend de la page en train d’être rendue.

<script>
	import { asset } from '$app/paths';
</script>

<img alt="a potato" src={asset('/potato.jpg')} />

function asset(file: Asset): string;

assets

Utilisez plutôt asset(...)

Un chemin absolu qui matche config.kit.paths.assets.

Si une valeur de config.kit.paths.assets est fournie, elle sera remplacé par '/_svelte_kit_assets' lors de vite dev ou vite preview, puisque les assets ne sont pas encore placés sur leur URL future.

let assets:
	| ''
	| `https://${string}`
	| `http://${string}`
	| '/_svelte_kit_assets';

base

Utilisez plutôt resolve(...)

Une chaîne de caractères qui matche config.kit.paths.base.

Exemple d’usage : <a href="{base}/your-page">Link</a>

let base: '' | `/${string}`;

match

Disponible depuis la version 2.52.0

Fait correspondre un chemin ou une URL à un ID de route et en extrait les paramètres.

import { match(alias) function match(url: Pathname | URL | (string & {})): Promise<{
    id: RouteId;
    params: Record<string, string>;
} | null>
import matchMatch a path or URL to a route ID and extracts any parameters.
import { match } from '$app/paths';

const route = await match('/blog/hello-world');

if (route?.id === '/blog/[slug]') {
	const slug = route.params.slug;
	const response = await fetch(`/api/posts/${slug}`);
	const post = await response.json();
}2.52.0
reference } from '$app/paths';

const routeconst route: {
    id: RouteId;
    params: Record<string, string>;
} | null = await match(alias) match(url: Pathname | URL | (string & {})): Promise<{
    id: RouteId;
    params: Record<string, string>;
} | null>
import matchMatch a path or URL to a route ID and extracts any parameters.
import { match } from '$app/paths';

const route = await match('/blog/hello-world');

if (route?.id === '/blog/[slug]') {
	const slug = route.params.slug;
	const response = await fetch(`/api/posts/${slug}`);
	const post = await response.json();
}2.52.0
reference('/blog/hello-world');

if (routeconst route: {
    id: RouteId;
    params: Record<string, string>;
} | null?.id(property) id: string | undefined === '/blog/[slug]') {
	const slugconst slug: string = routeconst route: {
    id: RouteId;
    params: Record<string, string>;
}.params(property) params: Record<string, string>.slugstring;
	const responseconst response: Response = await fetchfunction fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)MDN Reference
(`/api/posts/${slugconst slug: string}`);
	const postconst post: any = await responseconst response: Response.json(method) Body.json(): Promise<any>MDN Reference
();
}

function match(
	url: Pathname | URL | (string & {})
): Promise<{
	id: RouteId;
	params: Record<string, string>;
} | null>;

resolve

Disponible depuis la version 2.26

Résout un chemin en le préfixant avec le chemin de base, s’il existe, ou avec un ID de route en remplissant les segments dynamiques avec des paramètres.

Lors du rendu côté serveur, le chemin de base est relatif et dépend de la page en train d’être rendue.

import { resolve(alias) function resolve<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(...args: ResolveArgs<T>): ResolvedPathname
import resolveResolve a pathname by prefixing it with the base path, if any, or resolve a route ID by populating dynamic segments with parameters.
During server rendering, the base path is relative and depends on the page currently being rendered.
import { resolve } from '$app/paths';

// using a pathname
const resolved = resolve(`/blog/hello-world`);

// using a route ID plus parameters
const resolved = resolve('/blog/[slug]', {
	slug: 'hello-world'
});2.26
reference } from '$app/paths';

// avec un chemin
const resolvedconst resolved: string = resolve(alias) resolve<"/blog/hello-world">(route: "/blog/hello-world", params: Record<string, string>): ResolvedPathname
import resolveResolve a pathname by prefixing it with the base path, if any, or resolve a route ID by populating dynamic segments with parameters.
During server rendering, the base path is relative and depends on the page currently being rendered.
import { resolve } from '$app/paths';

// using a pathname
const resolved = resolve(`/blog/hello-world`);

// using a route ID plus parameters
const resolved = resolve('/blog/[slug]', {
	slug: 'hello-world'
});2.26
reference(`/blog/hello-world`);

// avec un ID de route et ses paramètres
const resolvedconst resolved: string = resolve(alias) resolve<"/blog/[slug]">(route: "/blog/[slug]", params: Record<string, string>): ResolvedPathname
import resolveResolve a pathname by prefixing it with the base path, if any, or resolve a route ID by populating dynamic segments with parameters.
During server rendering, the base path is relative and depends on the page currently being rendered.
import { resolve } from '$app/paths';

// using a pathname
const resolved = resolve(`/blog/hello-world`);

// using a route ID plus parameters
const resolved = resolve('/blog/[slug]', {
	slug: 'hello-world'
});2.26
reference('/blog/[slug]', {
	slug(property) slug: string: 'hello-world'
});

function resolve<
	T extends
		| RouteIdWithSearchOrHash
		| PathnameWithSearchOrHash
>(...args: ResolveArgs<T>): ResolvedPathname;

resolveRoute

Utilisez plutôt resolve(...)

function resolveRoute<
	T extends
		| RouteIdWithSearchOrHash
		| PathnameWithSearchOrHash
>(...args: ResolveArgs<T>): ResolvedPathname;

Modifier cette page sur Github llms.txt

précédent suivant

$app/navigation $app/server