---
title: "Feidhmeanna fóntais ``django.urls ``"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/urlresolvers/
canonical: https://djangodocs.dev/ga/6.1/ref/urlresolvers/
---
# Feidhmeanna fóntais django.urls \`\`

## droim () \`

The `reverse()` function can be used to return an absolute path reference
for a given view and optional parameters, similar to the [`url`](/ga/6.1/ref/templates/builtins/#std-templatetag-url) tag:

#### `reverse(viewname, urlconf=None, args=None, kwargs=None, current_app=None, * (Keyword-only parameters separator (PEP 3102)), query=None, fragment=None)`

`viewname` can be a [URL pattern name](/ga/6.1/topics/http/urls/#naming-url-patterns) or the
callable view object used in the URLconf. For example, given the following
`url`:

```
from news import views

path("archive/", views.archive, name="news-archive")
```

is féidir leat aon cheann de na nithe seo a leanas a úsáid chun an URL a aisiompú:

```
# using the named URL
reverse("news-archive")

# passing a callable object
# (This is discouraged because you can't reverse namespaced views this way.)
from news import views

reverse(views.archive)
```

Má ghlacann an URL le hargóintí, féadfaidh tú iad a chur i args\`. Mar shampla:

```
from django.urls import reverse

def myview(request):
    return HttpResponseRedirect(reverse("arch-summary", args=[1945]))
```

Is féidir leat `kwargs` a rith freisin in ionad `args`. Mar shampla:

```pycon
>>> reverse("admin:app_list", kwargs={"app_label": "auth"})
'/admin/auth/'
```

Ní féidir `args` agus `kwargs` a chur chuig reverse () ag an am céanna.

Mura féidir aon mheaitseáil a dhéanamh, ardaíonn reverse () eisceacht a:class: ~django.urls.noReverseMatch.

Is féidir leis an bhfeidhm ```reverse () ``éagsúlacht mhór patrúin léirithe rialta a aisiompú le haghaidh URLanna, ach ní gach ceann is féidir. Is é an príomhtheorannú i láthair na huaire nach féidir roghanna malartacha a bheith sa phatrún ag baint úsáide as an gcarachtar barra ingearach (```"|"). Is féidir leat patrúin den sórt sin a úsáid go sásta chun URLanna atá ag teacht isteach agus iad a sheoladh chuig tuairimí, ach ní féidir leat patrúin den sórt sin a aisiompú.

Ligeann an argóint `current_app` duit leid a sholáthar don réiteach a léiríonn an feidhmchlár lena mbaineann an radharc atá á fhorghníomhú faoi láthair. \<topics-http-reversing-url-namespaces\>Úsáidtear an argóint `current_app` seo mar leid chun spásanna ainmneacha feidhmchláir a réiteach i URLanna ar chásanna iarratais ar leith, de réir straitéise réitigh URL:ref: spaced ainmspaced URL .

Is é an argóint `urlconf` an modúl URLConf ina bhfuil na patrúin URL le húsáid chun aisiompú. De réir réamhshocraithe, úsáidtear an URLConf fréimhe don snáithe reatha.

The `query` keyword argument specifies parameters to be added to the returned
URL. It can accept an instance of [`QueryDict`](/ga/6.1/ref/request-response/#django.http.QueryDict) (such as
`request.GET`) or any value compatible with [`urllib.parse.urlencode()`](https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urlencode).
The encoded query string is appended to the resolved URL, prefixed by a `?`.

The `fragment` keyword argument specifies a fragment identifier to be
appended to the returned URL (that is, after the path and query string,
preceded by a `#`).

Mar shampla:

```pycon
>>> from django.urls import reverse
>>> reverse("admin:index", query={"q": "biscuits", "page": 2}, fragment="results")
'/admin/?q=biscuits&page=2#results'
>>> reverse("admin:index", query=[("color", "blue"), ("color", 1), ("none", None)])
'/admin/?color=blue&color=1&none=None'
>>> reverse("admin:index", query={"has empty spaces": "also has empty spaces!"})
'/admin/?has+empty+spaces=also+has+empty+spaces%21'
>>> reverse("admin:index", fragment="no encoding is done")
'/admin/#no encoding is done'
```

> **Note**
>
> \<uri-and-iri-handling\>Tá an teaghrán ar ais ag reverse () cheana féin: ref: urlquot. Mar shampla:
>
> ```pycon
> >>> reverse("cities", args=["Orléans"])
> '.../Orl%C3%A9ans/'
> ```
>
> D'fhéadfadh torthaí neamh-inmhianaithe a thabhairt ar ionchódú breise (mar shampla:func: urllib.parse.quote) a chur i bhfeidhm ar aschur reverse () .

> **Reversing class-based views by view object**
>
> The view object can also be the result of calling
> [`as_view()`](/ga/6.1/ref/class-based-views/base/#django.views.generic.base.View.as_view) if the same view object is
> used in the URLConf. Following the original example, the view object could
> be defined as:
>
> *`news/views.py`*
>
> ```python
>  from django.views import View
>
>
>  class ArchiveView(View): ...
>
>
>  archive = ArchiveView.as_view()
> ```
>
> However, remember that namespaced views cannot be reversed by view object.

## reverse\_leisciúil () \`

Leagan de reverse () \_ a mheastóireacht go leisciúil.

#### `reverse_lazy(viewname, urlconf=None, args=None, kwargs=None, current_app=None, * (Keyword-only parameters separator (PEP 3102)), query=None, fragment=None)`

Tá sé úsáideach nuair is gá duit aisiompú URL a úsáid sula luchtaítear URLConf do thionscadail. Is iad roinnt cásanna coitianta ina bhfuil an fheidhm seo riachtanach ná:

- URL aisghabháilte a sholáthar mar thréith url de radharc cineálach bunaithe ar aicme.
- URL aisghabháilte a sholáthar do mhaisitheoir (mar shampla an argóint login\_url don maisitheoir: func: django.contrib.auth.decorators.permission\_required).
- URL aisghabháilte a sholáthar mar luach réamhshocraithe do pharaiméadar i síniú feidhme.

## réiteach () \`\`

Is féidir an fheidhm resolution () a úsáid chun cosáin URL chuig na feidhmeanna amharc comhfhreagracha a réiteach. Tá an síniú seo a leanas aige:

#### `resolve(path, urlconf=None)`

Is é `path` an cosán URL is mian leat a réiteach. Mar atá le: func: ~django.urls.reverse, ní gá duit a bheith buartha faoin bparaiméadar `urlconf`. Tugann an fheidhm ar ais a: class: ResolverMatch réad a ligeann duit rochtain a fháil ar mheiteashonraí éagsúla faoin URL réitithe.

Mura réiteann an URL, ardaíonn an fheidhm eisceacht a:exc: ~django.urls.resolver404 (fo-aicme de:class: ~django.http.http404).

#### `class ResolverMatch`

#### `func`

An fheidhm amharc a úsáidfí chun freastal ar an URL

#### `args`

Na hargóintí a chuirfeadh ar aghaidh chuig an bhfeidhm amharc, mar a pháirsítear ón URL.

#### `kwargs`

Gach argóint eochairfhocal a chuirfeadh chuig an bhfeidhm amharc, i.e.:attr: ~resolvermatch.captured\_kwargs agus:attr: ~resolvermatch.extra\_kwargs.

#### `captured_kwargs`

Na hargóintí eochairfhocal gabháilte a chuirfeadh chuig an bhfeidhm amharc, mar a pháirsíodh ón URL.

#### `extra_kwargs`

Na hargóintí eochairfhocal breise a chuirfeadh chuig an bhfeidhm amharc.

#### `url_name`

Ainm an phatrún URL a mheaitseálann leis an URL.

#### `route`

Bealach an phatrún meaitseála URL.

\<id\>Mar shampla, más é ````path ('úsáideoirí/<id>/',...) ``an patrún meaitseála, beidh ```úsáideoirí//'```` i ```` ```beala ````.

#### `tried`

Rinne an liosta de phatrúin URL triail as sular mheaitseáil an URL patrúin amháin nó patrúin atá ar fáil ídithe.

#### `app_name`

An spás ainmneacha feidhmchláir don phatrún URL a mheaitseálann leis an URL.

#### `app_names`

An liosta de chomhpháirteanna ainmneacha aonair sa spás ainmneacha iomlán feidhmchláir don phatrún URL a mheaitseálann leis an URL. Mar shampla, más é `` `app_name `` `foo:bar'`, ansin `app_names` is `['foo', 'bar']`.

#### `namespace`

An spás ainmneacha sampla don phatrún URL a mheaitseálann leis an URL.

#### `namespaces`

An liosta de chomhpháirteanna ainmneacha aonair sa spás ainmneacha iomlán don phatrún URL a mheaitseálann leis an URL. ie, más é an spás ainmneacha `foo:bar`, ansin beidh spás ainmneacha `['foo', 'bar']`.

#### `view_name`

Ainm an radharc a mheaitseálann leis an URL, lena n-áirítear an spás ainmneacha má tá ceann ann.

A: aicme: Is féidir réad ResolverMatch a cheistiú ansin chun faisnéis a sholáthar faoin bpatrún URL a mheaitseálann le URL:

```
# Resolve a URL
match = resolve("/some/path/")
# Print the URL pattern that matches the URL
print(match.url_name)
```

A: aicme: Is féidir réad ResolverMatch a shannadh do thripla freisin:

```
func, args, kwargs = resolve("/some/path/")
```

Úsáid amháin a d'fhéadfadh a bheith de:func: ~django.urls.resolve ná tástáil a thabhairt an ardódh dearcadh earráid `Http404` sula ndéanfadh dearcadh a atreorú chuige:

```
from urllib.parse import urlsplit
from django.urls import resolve
from django.http import Http404, HttpResponseRedirect

def myview(request):
    next = request.META.get("HTTP_REFERER", None) or "/"
    response = HttpResponseRedirect(next)

    # modify the request and response as required, e.g. change locale
    # and set corresponding locale cookie

    view, args, kwargs = resolve(urlsplit(next).path)
    kwargs["request"] = request
    try:
        view(*args, **kwargs)
    except Http404:
        return HttpResponseRedirect("/")
    return response
```

## get\_script\_prefix () \`

#### `get_script_prefix()`

De ghnáth, ba chóir duit: func: ~django.urls.reverse a úsáid i gcónaí chun URLanna a shainiú laistigh de d'iarratas. Mar sin féin, má thógann d'fheidhmchlár cuid den ordlathas URL féin, b'fhéidir go mbeidh ort URLanna a ghiniúint ó am go chéile. Sa chás sin, ní mór duit a bheith in ann bunURL an tionscadail Django a aimsiú laistigh dá fhreastalaí gréasáin (de ghnáth, tugann: func: ~django.urls.reverse aire dó seo duit). Sa chás sin, is féidir leat glaoch ar get\_script\_prefix () , a thabharfaidh an chuid réimír script den URL ar ais do thionscadal Django. Má tá do thionscadal Django ag fréamh a fhreastalaí gréasáin, is é seo i gcónaí ” /".

> **Warning**
>
> Ní féidir an fheidhm seo \*\* a úsáid lasmuigh den timthriall iarrata-freagartha ós rud é go mbraitheann sé ar luachanna a thionscnaíodh le linn na timthrialla sin.