--- title: "Úsáideacha Django" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/ref/utils/ canonical: https://djangodocs.dev/ga/5.2/ref/utils/ --- # Úsáideacha Django Clúdaíonn an doiciméad seo gach modúl cobhsaí i `django.utils`. \Tá an chuid is mó de na modúil i django.utils\` deartha le haghaidh úsáide inmheánach agus ní féidir ach na codanna seo a leanas a mheas go cobhsaí agus dá bhrí sin comhoiriúnach ar ais de réir na:ref: beartas díghníomhaíochta scaoilte inmheánach. ## `django.utils.cache` Tá feidhmeanna cúntóra sa mhodúl seo chun caismú HTTP a rialú. Déanann sé amhlaidh trí cheannteideal freagraí `Vary` a bhainistiú. Cuimsíonn sé feidhmeanna chun ceanntásc na rudaí freagartha a phaisteáil go díreach agus maisitheoirí a athraíonn feidhmeanna chun an ceannteideal sin a dhéanamh iad féin. Le haghaidh faisnéise faoin gceannteideal `Vary`, féach:rfc: 9110 #section -12.5.5. Go bunúsach, sainmhíníonn an ceannteideal HTTP `Vary` cé na ceannteidil ba chóir do taisce a chur san áireamh agus a eochair taisce á thógáil. Ní mór d'iarratais leis an gcosán céanna ach ábhar ceanntásc difriúil do cheanntásca a ainmnítear in `Vary` eochracha taisce éagsúla a fháil chun ábhar mícheart a sheachadadh a Mar shampla, :doc: bheadh ar mheánghearraí idirnáisiúnaíochta idirdhealú a dhéanamh ar chaisce\ anna leis an gceannteideal Accept-Teanga . #### `patch_cache_control(response, **kwargs)` Paiseann an fheidhm seo an ceannteideal Cache-Control trí gach argóint eochairfhocal a chur leis. Is é seo a leanas an claochlú: - Déantar gach ainm paraiméadar eochairfhocal a chasadh go litreacha beaga, agus déantar béim a thiontú go hiphens. - Más luach paraiméadar `True` (go díreach `True`, ní fíor-luach amháin), ní chuirtear ach ainm an pharaiméadair leis an gceannteideal. - Cuirtear na paraiméadair eile go léir lena luach, tar éis str () a chur i bhfeidhm air. #### `get_max_age(response)` Tugann sé an t-aois uasta ar ais ón gceannteideal Cache-Control freagra mar shláimhir (nó `None` mura bhfuarthas é nó mura raibh sé ina slámhshláir). #### `patch_response_headers(response, cache_timeout=None)` Cuireann sé roinnt ceanntála úsáideacha leis an réad `HttpResponse` a thugtar: - Deireadh \`\` - Rialú Cache \`\` Ní chuirtear gach ceannteideal leis ach mura bhfuil sé socraithe cheana féin. Tá `cache_timeout` i soicindí. Úsáidtear an socrú: SETTING: CACHE\_MIDDLEWARE\_SECONDS de réir réamhshocraithe. #### `add_never_cache_headers(response)` Cuireann ceanntásc `Expires` leis an dáta/am reatha. Cuireann sé ceannteideal `Cache-Control: max-age = 0, no-cache, no-store, must-athbhailíniú, príobháideach` le freagra chun a léiriú nár chóir leathanach a chosc riamh. Ní chuirtear gach ceannteideal leis ach mura bhfuil sé socraithe cheana féin. #### `patch_vary_headers(response, newheaders)` Cuireann (nó nuashonraíonn sé) an ceannteideal `Vary` sa réad `HttpResponse` a thugtar. Is liosta d'ainmneacha ceanntásc is ea `newheaders` ar chóir a bheith i `Vary`. Má tá réiltín i gceanntásca, ansin beidh réiltín amháin `*'` comhdhéanta de cheanntásc `Vary`, de réir: rfc: 9110 #section -12.5.5. Seachas sin, ní bhaintear ceanntásca atá ann cheana i `Vary`. #### `get_cache_key(request, key_prefix=None, method='GET', cache=None)` Tugann eochair taisce ar ais bunaithe ar an gcosán iarratais. Is féidir é a úsáid i gcéim an iarratais toisc go dtarraingíonn sé liosta na gceanntásca le cur san áireamh ón gclárlann cosáin domhanda agus úsáideann sé iad siúd chun eochair taisce a thógáil chun seiceáil ina choinne. Mura bhfuil aon cheannliosta stóráilte ann, ní mór an leathanach a atógáil, mar sin filleann an fheidhm seo None . #### `learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None)` Foghlaimíonn sé cad iad na ceanntásca atá le cur san áireamh do chosán iarratais éigin ón réad freagartha Stórálann sé na ceannteidil sin i gclárlann cosáin domhanda ionas go mbeidh a fhios ag rochtain níos déanaí ar an gcosán sin cad iad na ceanntásca atá le cur san áireamh gan an réad Ainmnítear na ceanntásca i gceanntásc `Vary` den fhreagra, ach ba mhaith linn giniúint freagartha a chosc. Stóráiltear liosta na gceanntásca atá le húsáid le haghaidh giniúint eochair taisce sa taisce céanna leis na leathanaigh féin. Má thugann an taisce roinnt sonraí as an taisce, ciallaíonn sé seo go gcaithfimid an freagra a thógáil uair amháin chun teacht ar an gceannteideal Vary agus mar sin ag liosta na gceanntásc le húsáid don eochair taisce. ## `django.utils.dateparse` Tá na hairíonna seo a leanas ag na feidhmeanna atá sainmhínithe sa mhodúl seo - Glacann siad le teaghráin i bhformáidí dáta/ama ISO 8601 (nó roinnt roghanna dlúth) agus filleann siad rudaí ó na ranganna comhfhreagracha i modúl Python: MOD: datetime. - Ardaíonn siad: exc: ValueError má tá a n-ionchur formáidithe go maith ach nach dáta nó am bailí é. - Filleann siad None mura bhfuil sé formáidithe go maith ar chor ar bith. - Glacann siad suas le taifeach picosecond in ionchur, ach cuireann siad é a ghearradh go micreasoicind, ós rud é sin a thacaíonn Python le. #### `parse_date(value)` Déanann sé teaghrán a pháirseáil agus a: class: datetime.date ar ais. #### `parse_time(value)` Déanann sé teaghrán a pháirseáil agus a: class: datetime.time ar ais. Ní thacaítear le háirithe UTC; má chuireann `luach` cur síos ar cheann amháin, is é `None` an toradh. #### `parse_datetime(value)` Déanann sé teaghrán a pháirseáil agus a: class: datetime.datetime ar ais. Tacaítear le hoiriúintí UTC; má chuireann `value` cur síos ar cheann amháin, is é a: class: datetime.timezone tréith `tzinfo` an torthaí. #### `parse_duration(value)` Déanann sé teaghrán a pháirseáil agus a: class: datetime.timedelta ar ais. Tá súil ag súil le sonraí san fhormáid `"DD HH:MM:SS.uuuuuuu"`, `"DD HH:MM:SS, uuuuuu"`, nó mar a shonraítear le ISO 8601 (m.sh. P4DT1H15M20S\` atá coibhéis le ```4 1:15:20 ``) nó formáid eatramh lae-ama PostgreSQL (m.sh. `3 lá 04:05:06```). ## django.utils.decorators \`\` #### `method_decorator(decorator, name='')` Athraíonn maisitheoir feidhme ina mhaisitheoir modh. Is féidir é a úsáid chun modhanna nó ranganna a mhaisiú; sa chás deireanach, is é ```ainm ``ainm``` ainm an mhodha atá le maisiú agus tá sé riachtanach. D'fhéadfadh go mbeadh “maisitheoir” ina liosta nó tiúpla feidhmeanna freisin. Tá siad fillte in ord droim ionas gurb é an t-ordú glaonna an t-ord ina bhfuil na feidhmeanna le feiceáil sa liosta/tuple. Féach: tagairt: tuairimí bunaithe ar rang a mhaisiú \\`mar shampla úsáid. #### `decorator_from_middleware(middleware_class)` Mar gheall ar rang lár-earraí, filleann sé maisitheoir radharc ar ais. Ligeann sé seo duit feidhmiúlacht middleware a úsáid ar bhonn aghaidh an amharc. Cruthaítear an middleware gan aon pharams a rith. Glacann sé le middleware atá comhoiriúnach le seanstíl Django 1.9 agus níos luaithe (modhanna mar process\_request () \`, process\_exception ()\`, agus process\_response () ). #### `decorator_from_middleware_with_args(middleware_class)` Cosúil le decorator\_from\_middleware\`, ach filleann feidhm a ghlacann leis na hargóintí atá le cur chuig an middleware\_class. Mar shampla, cruthaítear maisitheoir:func: ~django.views.decorators.cache.cache\_page ón cacheMiddleware\` mar seo: ``` cache_page = decorator_from_middleware_with_args(CacheMiddleware) @cache_page(3600) def my_view(request): pass ``` #### `sync_only_middleware(middleware)` \Marcaíonn sé meán-earraí mar: ref: synchronous-only . (An réamhshocrú i Django, ach tugann sé seo deis duit cruthúnas sa todhchaí má athraíonn an réamhshocrú riamh i scaoileadh amach anseo.) #### `async_only_middleware(middleware)` \Marcálann sé meán-earraí mar: ref: asynchronous-only . Fillfidh Django é i lúb imeachta asincrónach nuair a ghlaofar air ón gcosán iarratais WSGI. #### `sync_and_async_middleware(middleware)` Marcálann sé meán-earraí mar: ref: sync agus async comhoiriúnach \, ceadaíonn sé seo iarratais a thiontú a sheachaint. Ní mór duit braite an cineál iarratais reatha a chur i bhfeidhm chun an maisitheoir seo a úsáid. \Féach: ref: doiciméadú middleware asincrónach le haghaidh sonraí. ## `django.utils.encoding` #### `smart_str(s, encoding='utf-8', strings_only=False, errors='strict')` Filleann sé réad `str` a léiríonn réad treallach `s`. Déileálann sé le bytestrings ag baint úsáide as an codec `encoding`. Má tá `strings_only` `True`, ná tiontaigh (roinnt) rudaí neamh-shreangacha. #### `is_protected_type(obj)` Faigh amach an bhfuil an t-ábhar réada de chineál cosanta. Caomhnaítear rudaí de chineálacha cosanta mar atá nuair a chuirtear ar aghaidh chuig force\_str (strings\_only=true) . #### `force_str(s, encoding='utf-8', strings_only=False, errors='strict')` Cosúil le smart\_str () , ach amháin go ndéantar cásanna leisciúla a réiteach ar teaghráin, seachas a choinneáil mar rudaí leisciúla. Má tá `strings_only` `True`, ná tiontaigh (roinnt) rudaí neamh-shreangacha. #### `smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')` Tugann sé leagan bytestring de réad treallach `s`, ionchódaithe mar a shonraítear i `encoding`. Má tá `strings_only` `True`, ná tiontaigh (roinnt) rudaí neamh-shreangacha. #### `force_bytes(s, encoding='utf-8', strings_only=False, errors='strict')` Cosúil le `smart_bytes`, ach amháin go ndéantar cásanna leisciúla a réiteach ar bytestrings, seachas a choinneáil mar rudaí leisciúla. Má tá `strings_only` `True`, ná tiontaigh (roinnt) rudaí neamh-shreangacha. #### `iri_to_uri(iri)` Tiontaigh cuid Aitheantóir Acmhainní Idirnáisiúnta (IRI) go cuid URI atá oiriúnach lena áireamh i URL. Seo an algartam ó chuid 3.1 de:rfc: 3987 #section -3.1, atá beagán simplithe ós rud é go nglactar leis gur sreang é an t-ionchur seachas sruth beot treallach. Tógann sé IRI (sreang nó UTF-8 bytes) agus filleann sé teaghrán ina bhfuil an toradh ionchódaithe. #### `uri_to_iri(uri)` Athraíonn Aitheantóir Acmhainní Aonfhoirmeach ina Aitheantóir Acmhainní Idir Is algartam é seo ó chuid 3.2 de:rfc: 3987 #section -3.2. Tógann sé URI i mbeátaí ASCII agus filleann sé teaghrán ina bhfuil an toradh ionchódaithe. #### `filepath_to_uri(path)` Tiontaigh cosán córais chomhaid go cuid URI atá oiriúnach le cuimsiú i URL. Glactar leis gurb é an cosán UTF-8 bytes, string, nó a: class: ~pathLib.path. Ionchódfaidh an modh seo carachtair áirithe a d'aithníodh de ghnáth mar charachtair speisialta do URIs. Tabhair faoi deara nach ndéanann an modh seo an carachtar 'a ionchódú, toisc gur carachtar bailí é laistigh de URIs. Féach feidhm JavaScript EncodeuriComponent () le haghaidh tuilleadh sonraí. Filleann sé teaghrán ASCII ina bhfuil an toradh ionchódaithe. #### `escape_uri_path(path)` Éalaíonn sé na carachtair neamhshábháilte ón gcuid cosáin d'Aitheantóir Acmhainní Aonfhoirmeach (URI). ## `django.utils.feedgenerator` Úsáid samplach: ```pycon >>> from django.utils import feedgenerator >>> feed = feedgenerator.Rss201rev2Feed( ... title="Poynter E-Media Tidbits", ... link="https://www.poynter.org/tag/e-media-tidbits/", ... description="A group blog by the sharpest minds in online media/journalism/publishing.", ... language="en", ... ) >>> feed.add_item( ... title="Hello", ... link="https://www.holovaty.com/test/", ... description="Testing.", ... ) >>> with open("test.rss", "w") as fp: ... feed.write(fp, "utf-8") ... ``` Chun roghnú gineadóir a shimpliú bain úsáid as `FeedGenerator.defaultFeed` atá `RSS201Rev2Feed` faoi láthair Le haghaidh sainmhínithe ar na leaganacha éagsúla de RSS, féach: #### `get_tag_uri(url, date)` Cruthaíonn TagUri. Féach ### `Stylesheet` > **New in Django 5.2** #### `class Stylesheet(url, mimetype='', media='screen')` Represents an RSS stylesheet. #### `url` Required argument. The URL where the stylesheet is located. #### `mimetype` An optional string containing the MIME type of the stylesheet. If not specified, Django will attempt to guess it by using Python's [`mimetypes.guess_type()`](https://docs.python.org/3/library/mimetypes.html#mimetypes.guess_type). Use `mimetype=None` if you don't want your stylesheet to have a MIME type specified. #### `media` An optional string which will be used as the `media` attribute of the stylesheet. Defaults to `"screen"`. Use `media=None` if you don't want your stylesheet to have a `media` attribute. ### `SyndicationFeed` #### `class SyndicationFeed` Aicme bonn do gach fotha sindiciúcháin. Ba chóir go gcuirfeadh fo-aicmí scríobh () a sholáthar. #### `__init__(title, link, description, language=None, author_email=None, author_name=None, author_link=None, subtitle=None, categories=None, feed_url=None, feed_copyright=None, feed_guid=None, ttl=None, stylesheets=None, **kwargs)` Cuir tús leis an bhfoclóir meiteashonraí a thugtar, a bhaineann leis an mbeatha iomlán. Stórálfar aon argóintí eochairfhocal breise a chuireann tú chuig `__init__` i self.feed\`. All parameters should be strings, except for two: - Ba chóir go mbeadh “catagóirí” ina seicheamh teaghráin. - `stylesheets` should be a sequence of either strings or [`Stylesheet`](#django.utils.feedgenerator.Stylesheet) instances. > **Changed in Django 5.2** > > The `stylesheets` argument was added. #### `add_item(title, link, description, author_email=None, author_name=None, author_link=None, pubdate=None, comments=None, unique_id=None, categories=(), item_copyright=None, ttl=None, updateddate=None, enclosures=None, **kwargs)` Cuireann mír leis an mbeatha. Táthar ag súil go mbeidh teaghráin iad gach arg ach amháin `pubdate` agus `updateddate`, ar rudaí datetime.datetime\` iad, agus `enclosures`, ar liosta de chásanna `Enclosure`. #### `num_items()` #### `root_attributes()` Tabhair ar ais tréithe breise le cur ar an eilimint fréimhe (ie beath/cainéal). Glaoigh ó write () . #### `add_root_elements(handler)` Cuir eilimintí san eilimint fréimhe (ie beath/cainéal). Glaoigh ó write () . #### `add_stylesheets(self, handler)` > **New in Django 5.2** Add stylesheet information to the document. Called from `write()`. #### `item_attributes(item)` Tabhair ar ais tréithe breise le cur ar gach eilimint (ie ear/iontráil). #### `add_item_elements(handler, item)` Cuir eilimintí ar gach eilimint (ie ear/iontráil). #### `write(outfile, encoding)` Aisíonn sé an beatha san ionchódú a thugtar chuig `outfile`, ar réad cosúil le comhad é. Ba chóir go gcuirfeadh fo-aicmí é seo a chur #### `writeString(encoding)` Tugann an beatha ar ais san ionchódú a thugtar mar shreang. #### `latest_post_date()` Filleann sé an `pubdate` nó `updateddate` is déanaí do gach earra sa bhfotha. Mura bhfuil aon earraí ceachtar de na tréithe seo filleann sé seo an dáta/am reatha UTC ar ais. ### `Cumhd` #### `class Enclosure` Léiríonn sé imfhálú RSS ### `RSSFeed` #### `class RssFeed(SyndicationFeed)` ### `RSS201REV2Feed` #### `class Rss201rev2Feed(RssFeed)` Sonraíocht: ### `RSSuserland091Feed` #### `class RssUserland091Feed(RssFeed)` Sonraíocht: ### `Atom1Feed` #### `class Atom1Feed(SyndicationFeed)` Sonraíocht: :rfc: 4287 ## `django.utils.functional` #### `class cached_property(func)` Cuireann an maisitheoir `@cached_property` toradh modh le hargóint féin\` amháin mar mhaoin. Leanfaidh an toradh taisceáilte chomh fada agus a dhéanann an cás, mar sin má chuirtear an cás timpeall agus má ghairmtear an fheidhm ina dhiaidh sin, cuirfear an toradh taisceáilte ar ais. Smaoinigh ar chás tipiciúil, ina bhféadfadh go mbeadh gá le dearcadh modh samhail a ghlaoch chun ríomh éigin a dhéanamh, sula gcuirtear an t-áis samhail isteach sa chomhthéacs, áit a bhféadfadh an teimpléad an modh a ghairm arís: ``` # the model class Person(models.Model): def friends(self): # expensive computation ... return friends # in the view: if person.friends(): ... ``` Agus sa teimpléad bheadh agat: ```html+django {% for friend in person.friends %} ``` Anseo, glaofar ar cairde () \`\`faoi dhó. Ós rud é go bhfuil an cás \`\`pearsa\` sa radharc agus an teimpléad mar an gcéanna, is féidir an modh ```cairde () ``a mhaisiú le``` @cached\_property a sheachaint: ``` from django.utils.functional import cached_property class Person(models.Model): @cached_property def friends(self): ... ``` Tabhair faoi deara toisc gur maoin é an modh anois, i gcód Python caithfear rochtain a fháil go cuí air: ``` # in the view: if person.friends: ... ``` Is féidir an luach taisceáilte a chóireáil mar ghnáthtréith den chás: ``` # clear it, requiring re-computation next time it's called person.__dict__.pop("friends", None) # set a value manually, that will persist on the instance until cleared person.friends = ["Huckleberry Finn", "Tom Sawyer"] ``` Mar gheall ar an mbealach a oibríonn an prótacal tuairiscí:py:ref: Descriptor\`\, ardaíonn \`\`del\` (nó delattr\`) ar cached\_property\` nár rochtainíodh rochtain air `AttributeError`. Chomh maith le buntáistí feidhmíochta féideartha a thairiscint, is féidir le `@cached_property` a chinntiú nach n-athróidh luach tréithe gan choinne thar shaol an cháis. D'fhéadfadh sé seo tarlú le modh a bhfuil a ríomh bunaithe ar datetime.now () \`, nó má shábháiltear athrú ar an mbunachar sonraí trí phróiseas éigin eile san eatramh gairid idir inghairmithe modh ina dhiaidh sin ar an gcás céanna. Is féidir leat airíonna taisceáilte modhanna a dhéanamh. Mar shampla, má bhí modh daor get\_friends () agat agus má theastaigh uait é a ghlaoch gan an luach taisceáilte a aisghabháil, d'fhéadfá scríobh: ``` friends = cached_property(get_friends) ``` Cé go ndéanfaidh person.get\_friends () na cairde a athríomh ar gach glao, leanfaidh luach na maoine a choscáil go dtí go scriosann tú í mar a thuairiscítear thuas: ``` x = person.friends # calls first time y = person.get_friends() # calls again z = person.friends # does not call x is z # is True ``` #### `class classproperty(method=None)` Cosúil le:py:func: @classmethod\`\, athraíonn an maisitheoir \`\`@classproperty\` toradh modh le argóint `cls` amháin ina maoin ar féidir rochtain a fháil go díreach ón rang. #### `keep_lazy(func, *resultclasses)` Cuireann Django go leor feidhmeanna fóntais ar fáil (go háirithe i `django.utils`) a ghlacann sreang mar an gcéad argóint agus a dhéanann rud éigin leis an sreang sin. Úsáidtear na feidhmeanna seo ag scagairí teimpléid chomh maith le go díreach i gcód eile. Má scríobhann tú do chuid feidhmeanna comhchosúla féin agus má dhéileálann tú le haistriúcháin, beidh fadhb agat cad atá le déanamh nuair is réad aistriúcháin leisciúil é an chéad argóint. Níl tú ag iarraidh é a thiontú go sreang láithreach, mar b'fhéidir go bhfuil an fheidhm seo á úsáid agat lasmuigh de radharc (agus dá bhrí sin ní bheidh socrú áitiúil an snáithe reatha ceart). Maidir le cásanna mar seo, bain úsáid as an maisitheoir django.utils.functional.keep\_lazy () . Athraíonn sé an fheidhm ionas ionas gur\* má thugtar air le haistriúchán leisciúil mar cheann dá argóintí, cuirtear moill ar an meastóireacht feidhme go dtí go gcaithfear é a thiontú go sreang. Mar shampla: ``` from django.utils.functional import keep_lazy, keep_lazy_text def fancy_utility_function(s, *args, **kwargs): # Do some conversion on string 's' ... fancy_utility_function = keep_lazy(str)(fancy_utility_function) # Or more succinctly: @keep_lazy(str) def fancy_utility_function(s, *args, **kwargs): ... ``` Tógann an maisitheoir ```keep_lazy () ``roinnt argóintí breise (``*args```) a shonraíonn an cineál/na cineálacha is féidir leis an bhfeidhm bhunaidh a thabhairt ar ais. Cás úsáide coitianta is ea feidhmeanna a bheith agat a thugann téacs ar ais. Chuige seo, is féidir leat an cineál `str` a chur chuig keep\_lazy\` (nó bain úsáid as an maisitheoir: func: keep\_lazy\_text a thuairiscítear sa chéad chuid eile). Ciallaíonn an maisitheoir seo a úsáid gur féidir leat do fheidhm a scríobh agus glacadh leis gur sreang ceart é an t-ionchur, ansin tacaíocht a chur le haghaidh rudaí aistriúcháin leisciúil ag an deireadh. #### `keep_lazy_text(func)` Aicearra le haghaidh keep\_lazy (str) (func) . Má tá feidhm agat a thugann téacs ar ais agus má theastaíonn uait a bheith in ann argóintí leisciúla a ghlacadh agus tú ag moill ar a meastóireacht, is féidir leat an maisitheoir seo a úsáid: ``` from django.utils.functional import keep_lazy, keep_lazy_text # Our previous example was: @keep_lazy(str) def fancy_utility_function(s, *args, **kwargs): ... # Which can be rewritten as: @keep_lazy_text def fancy_utility_function(s, *args, **kwargs): ... ``` ## `django.utils.html` De ghnáth ba chóir duit HTML a thógáil ag baint úsáide as teimpléid Django chun a mheicníocht autoescape a úsáid, ag baint úsáide as na fóntais in:mod: django.utils.safestring nuair is cuí. Soláthraíonn an modúl seo roinnt fóntais leibhéal íseal breise chun HTML a éalú. #### `escape(text)` Tugann sé an téacs a thugtar ar ais le ampersandaí, luachana agus lúibíní uillinne ionchódaithe le húsáid i HTML. Cuirtear iallach ar an ionchur ar dtús chuig sreang agus tá: func: ~django.utils.safestring.mark\_safe curtha i bhfeidhm ar an aschur. #### `conditional_escape(text)` Cosúil le escape () , ach amháin nach n-oibríonn sé ar teaghráin réamh-éalaithe, mar sin ní éalóidh sé dúbailte. #### `format_html(format_string, *args, **kwargs)` Tá sé seo cosúil le:meth: str.format, ach amháin go bhfuil sé oiriúnach chun blúirí HTML a thógáil suas. Ní éaltar an chéad argóint `format_string` ach cuirtear gach args agus kwargs eile trí:func: conditional\_escape sula gcuirtear ar aghaidh chuig str.format () \`. Faoi dheireadh, tá: func: ~django.utils.safestring.mark\_safe curtha i bhfeidhm ar an aschur. Maidir le blúirí beaga HTML a thógáil, is fearr leis an bhfeidhm seo ná idirphallú sreangán ag baint úsáide as %\` nó str.format () go díreach, toisc go mbaineann sé éalú le gach argóint - díreach mar a chuireann an córas teimpléid i bhfeidhm ag éalú de réir réamhshocraithe. Mar sin, in ionad scríobh: ``` mark_safe( "%s %s %s" % ( some_html, escape(some_text), escape(some_other_text), ) ) ``` Ba chóir duit ina ionad sin a úsáid: ``` format_html( "{} {} {}", mark_safe(some_html), some_text, some_other_text, ) ``` Tá an buntáiste aige seo nach gá duit iarratas a dhéanamh: func: éalú chuig gach argóint agus go mbeidh fabht agus leochaileacht XSS i mbaol má dhéanann tú dearmad ar cheann amháin. Tabhair faoi deara cé go n-úsáideann an fheidhm seo ```str.format () ``chun an t-idirghabháil a dhéanamh, ní oibreoidh cuid de na roghanna formáidithe a sholáthraíonn ``str.format ()``` (m.sh. formáidiú uimhir), ós rud é go gcuirtear gach argóint trí:func: func: force\_str ar an luachanna. > **Deprecated since Django 5.0** > > Deprecated since version 5.0: Tá an tacaíocht chun glaoch ar format\_html () gan args nó kwargs a rith a chur as. #### `format_html_join(sep, format_string, args_generator)` Fillteán de:func: format\_html, maidir le cás coitianta grúpa argóintí a chaithfear iad a fhormáidiú ag baint úsáide as an sreang formáide céanna, agus ansin a cheangal ag baint úsáide as `sep`. Cuirtear `sep` trí:func: conditional\_escape freisin. `args_generator` should be an iterator that yields arguments to pass to [`format_html()`](#django.utils.html.format_html), either sequences of positional arguments or mappings of keyword arguments. For example, tuples can be used for positional arguments: ``` format_html_join( "\n", "
  • {} {}
    • ", ((u.first_name, u.last_name) for u in users), ) ``` Or dictionaries can be used for keyword arguments: ``` format_html_join( "\n", '
  • {id} {title}
    • ', ({"id": b.id, "title": b.title} for b in books), ) ``` > **Changed in Django 5.2** > > Support for mappings in `args_generator` was added. #### `json_script(value, element_id=None, encoder=None)` Éalaíonn sé gach carachtar speisialta HTML/XML lena n-éalaíonn Unicode, mar sin tá an luach sábháilte le húsáid le JavaScript. Fillteann sé an JSON éalaithe i gclib \\`\`\`\` freisin. \Mura bhfuil an paraiméadar `element_id` ``` `None ``, tugtar an id rith don chlib ``` . Mar shampla: ```pycon >>> json_script({"hello": "world"}, element_id="hello-data") '' ``` Úsáidfear an `encoder`, atá réamhshocraithe to:class: django.core.serializers.json.djangojsonEncoder, chun na sonraí a shraitheadh. Féach: Ref: JSON sraitheoireacht \\`le haghaidh tuilleadh sonraí faoin sraitheoir seo. #### `strip_tags(value)` Déanann iarracht aon rud atá cosúil le clib HTML a bhaint as an sreang, is é sin aon rud atá laistigh de \<\>\`. Absolutely NO guarantee is provided about the resulting string being HTML safe. So NEVER mark safe the result of a `strip_tags` call without escaping it first, for example with [`escape()`](#django.utils.html.escape). Mar shampla: ``` strip_tags(value) ``` Más é `luach` `” Is slug é Joel “` is é an luach tuai \ris\ ceáin `"Is slug é Joel"`. Má tá réiteach níos láidre á lorg agat, smaoinigh ar uirlis sláintíochta HTML tríú páirtí a úsáid. #### `html_safe()` Cuidíonn an modh \_\_html\_\_ () ar rang le teimpléid neamh-DJango ranganna a bhrath nach dteastaíonn a n-aschur ag éalú HTML. Sainmhíníonn an maisitheoir seo an modh ```__html__ () ``ar an rang maisithe trí ``__str__ ()``` a fhilleadh in:meth: ~django.utils.safestring.mark\_safe. Déan cinnte go gcuireann an modh \_\_str\_\_ () téacs ar ais go deimhin nach dteastaíonn éalú HTML uaidh. ## `django.utils.http` #### `urlencode(query, doseq=False)` Leagan de fheidhm Python: Func: urllib.parse.urlencode atá in ann oibriú ar `multivaluedict` agus luachanna neamh-sreang. #### `http_date(epoch_seconds=None)` Formáidigh an t-am chun an formáid dáta: rfc: 1123 #section -5.2.14 a mheaitseáil mar a shonraíonn : 9110 #section -5.6.7. Glacann sé le huimhir phointe snámh a chuirtear in iúl i soicindí ón tréimhse in UTC - mar shampla an líon a chuirtear amach ag ```time.time () `. Má tá sé socraithe ar ``None```, réamhshocraithe go dtí an t-am reatha. Aischuir sreang san fhormáid `Wdy, DD Mon YYYY HH:MM: SS GMT`. #### `content_disposition_header(as_attachment, filename)` Tógann sé luach ceanntásc HTTP `Content-Disposition` ón ```ainm comhad ``tugtar mar a shonraítear ar:rfc: `6266`. Tugann ``None``` má tá `as_attachment` `False` agus ````ainm comhaid ```None````, seachas sin filleann sé sreang atá oiriúnach don cheannteideal HTTP `Content-Disposition`. #### `base36_to_int(s)` Athraíonn sé sreang bonn 36 go sláimhir. #### `int_to_base36(i)` Athraíonn sé sláimhir dhearfach go bun-sreang 36. #### `urlsafe_base64_encode(s)` Ionchódaíonn bytestring chuig teaghrán base64 le húsáid in URLanna, ag scriosadh aon chomharthaí comhionanna rianacha. #### `urlsafe_base64_decode(s)` Déan teaghrán ionchódaithe base64 a dhíchódú, ag cur siar aon chomharthaí comhionannacha a d'fhéadfadh a bheith bainte amach. ## `django.utils.module_loading` Feidhmeanna chun oibriú le modúil Python. #### `import_string(dotted_path)` Ionmhairíonn cosán modúl poncanach agus cuireann sé an tréith/rang ainmnithe leis an ainm deireanach sa chosán ar ais. Ardaíonn sé allmhaireacht má theip ar an allmhairiú. Mar shampla: ``` from django.utils.module_loading import import_string ValidationError = import_string("django.core.exceptions.ValidationError") ``` atá coibhéiseach le: ``` from django.core.exceptions import ValidationError ``` ## `django.utils.safestring` Feidhmeanna agus ranganna chun oibriú le “teaghráin sábháilte”: teaghráin is féidir a thaispeáint go sábháilte gan éalú breise i HTML. Ciallaíonn rud éigin a mharcáil mar “teaghrán sábháilte” go bhfuil táirgeoir an teaghráin tar éis carachtair a iompú cheana féin nár cheart ag an inneall HTML (m.sh. '\<') iad a léirmhíniú sna heintitis iomchuí. #### `class SafeString` Fo-aicme str\` atá marcáilte go sonrach mar “sábháilte” (ní gá éalú breise) chun críocha aschuir HTML. #### `mark_safe(s)` Marcáil sreang go sainráite mar shábháilte chun críocha aschuir (HTML). Is féidir an réad a chuirtear ar ais a úsáid i ngach áit a bhfuil sreang oiriúnach. Is féidir é a ghlaoch arís agus arís eile ar shreang amháin. Is féidir é a úsáid freisin mar mhaisitheoir. Chun blúirí HTML a thógáil, ba chóir duit de ghnáth a bheith ag baint úsáidea:func: django.utils.html.format\_html ina ionad. Beidh sreang marcáilte sábháilte neamhshábháilte arís Mar shampla: ```pycon >>> mystr = "Hello World " >>> mystr = mark_safe(mystr) >>> type(mystr) >>> mystr = mystr.strip() # removing whitespace >>> type(mystr) ``` ## `django.utils.text` #### `format_lazy(format_string, *args, **kwargs)` Leagan de:meth: str.format nuair a bhíonn rudaí leisciúla ag `format_string`, args\`, agus/nó `kwargs`. Is é an chéad argóint an sreang atá le formáidiú. Mar shampla: ``` from django.utils.text import format_lazy from django.utils.translation import pgettext_lazy urlpatterns = [ path( format_lazy("{person}//", person=pgettext_lazy("URL", "person")), PersonDetailView.as_view(), ), ] ``` Ligeann an sampla seo d'aistritheoirí cuid den URL a aistriú. Má aistrítear “duine” go “persona”, meaitneoidh an abairt rialta `persona/ (? P\ d+) /$`, m.sh. `persona/5/`. #### `slugify(value, allow_unicode=False)` Athraíonn sé sreang go slug URL trí: 1. Ag tiontú go ASCII más é `allow_unicode` False\` (an réamhshocraithe). 2. Ag tiontú go litreacha beaga. 3. Carachtair nach alfaiméireacha, béim, braithíní nó spás bán iad a bhaint. 4. Aon spás bán nó sraitheanna arís agus arís agus arís eile a chur in ionad stiúir aonair. 5. Spás bán tosaigh agus rianúcháin a bhaint, sraitheanna agus béim a bhaint. Mar shampla: ```pycon >>> slugify(" Joel is a slug ") 'joel-is-a-slug' ``` Más mian leat carachtair Unicode a cheadú, pas `allow_unicode=true`. Mar shampla: ```pycon >>> slugify("你好 World", allow_unicode=True) '你好-world' ``` ## django.utils.timezone \`\` #### `get_fixed_timezone(offset)` Tugann a: class: ~datetime.tzinfo sampla a léiríonn crios ama le fritháireamh seasta ó UTC. Is é `offset` a:class: datetime.timedelta nó líon sláireach nóiméad. Úsáid luachanna dearfacha do chriosanna ama thoir ó UTC agus luachanna diúltacha siar de UTC. #### `get_default_timezone()` \Tugann a:class: ~datetime.tzinfo sampla a léiríonn an:ref: crios ama réamhshocraithe . #### `get_default_timezone_name()` \Tugann ainm an: ref: crios ama réamhshocraithe ar ais. #### `get_current_timezone()` \Tuairisceann a:class: ~datetime.tzinfo sampla a léiríonn an:ref: crios ama reatha . #### `get_current_timezone_name()` \Tugann ainm an: ref: crios ama reatha ar ais. #### `activate(timezone)` \Socraíonn an: ref: crios ama reatha \`. Caithfidh an argóint \`timezone\` a bheith ina shampla de a:class: ~datetime.tzinfo fo-aicme nó ainm crios ama. #### `deactivate()` \Díshuitear an:ref: crios ama reatha . #### `override(timezone)` Is bainisteoir comhthéacs Python é seo a shocraíonn an: ref: crios ama reatha \\`ar iontráil le:func: \`activate (), agus a athshlánú an crios ama atá gníomhach roimhe seo ar imeacht. \Más é `None` an argóint crios ama , díshocraítear an:ref: crios ama reatha \`ar iontráil le:func: \`díghníomhachtú () ina ionad. Tá `override` inúsáidte mar mhaisitheoir feidhme freisin. #### `localtime(value=None, timezone=None)` \Athraíonn sé aware:class: ~datetime.datetime go crios ama difriúil, de réir réamhshocraithe an:ref: crios ama reatha . Nuair a fhágtar luach , réamhshocraithe aith:func: ano. Ní oibríonn an fheidhm seo ar amanna dáta naif; úsáid: func: make\_aware ina ionad. #### `localdate(value=None, timezone=None)` \Úsáid:Func: localtime chun aware:class: ~datetime.datetime a thiontú go a:meth: ~datetime.datetime.date i gcrios ama difriúil, de réir réamhshocraithe an:ref: crios ama reatha . Nuair a fhágtar luach , réamhshocraithe aith:func: ano. Ní oibríonn an fheidhm seo ar amanna dáta naif. #### `now()` Tuairisceáin a: class: ~datetime.datetime a léiríonn an pointe reatha in am. Braitheann an méid a chuirtear ar ais go díreach ar luach de:setting: USE\_TZ: - Más rud é: Setting: `False` USE\_TZ, is é seo a: ref: naive dáta-am \(ie dáta-am gan crios ama gaolmhar) a léiríonn an t-am reatha i gcrios ama áitiúil an chórais. - \Más rud é: Setting: USE\_TZ `True`, beidh sé seo an:ref: aware \`dáta-am a léiríonn an t-am reatha i UTC. Tabhair faoi deara go bhfillfidh: func: \`ano amanna i gcónaí i UTC beag beann ar luach an:setting: TIME\_ZONE; is féidir leat:func: localtime a úsáid chun an t-am a fháil sa chrios ama reatha. #### `is_aware(value)` Tugann sé ar ais `Fíor` má tá luach\` ar an eolas, `Fréag` má tá sé naif. Glacann an fheidhm seo leis gurb é `luach` a:class: ~datetime.datetime. #### `is_naive(value)` Tugann sé ar ais `True` má tá luach\` naif, `Fréag` má tá sé ar an eolas aige. Glacann an fheidhm seo leis gurb é `luach` a:class: ~datetime.datetime. #### `make_aware(value, timezone=None)` Filleann sé aware:class: ~datetime.datetime a léiríonn an pointe céanna in am le `value` i timezone\`, agus value\` ina naive:class: ~datetime.datetime. \Má tá `timezone` socraithe go `None`, réamhshocraíonn sé go dtí an:ref: crios ama reatha . #### `make_naive(value, timezone=None)` Tugann naive:class: ~datetime.datetime ar ais a léiríonn i `timezone` an pointe céanna in am le `value`, agus lua\` atá ina aware:class: ~datetime.datetime. \Má tá `timezone` socraithe go `None`, réamhshocraíonn sé go dtí an:ref: crios ama reatha . ## `django.utils.translation` Le haghaidh plé iomlán maidir le húsáid na nithe seo a leanas féach na:doc: doiciméadú aistriúcháin \. #### `gettext(message)` Aistríonn teachtaireacht agus cuireann sé ar ais mar shreang é. #### `pgettext(context, message)` Aistríonn ```teachtaireacht ``mar gheall ar an `comhthéacs``` agus cuireann sé ar ais mar shreang é. Le haghaidh tuilleadh faisnéise, féach:ref: contextual-markers. #### `gettext_lazy(message)` #### `pgettext_lazy(context, message)` Mar an gcéanna leis na leaganacha neamh-leisciúla thuas, ach ag baint úsáide as forghní \Féach:ref: doiciméadú aistriúcháin leisciúil . #### `gettext_noop(message)` Marcálann sé teaghráin le haghaidh aistriúcháin ach ní aistríonn sé iad anois. Is féidir é seo a úsáid chun teaghráin a stóráil in athróga domhanda ar chóir dóibh fanacht sa bhuntheanga (toisc go bhféadfaí iad a úsáid go seachtrach) agus aistrítear iad níos déanaí. #### `ngettext(singular, plural, number)` Aistríonn `singular` agus plural\` agus filleann sé an teaghrán cuí bunaithe ar `uimhre`. #### `npgettext(context, singular, plural, number)` Aistríonn `singular` agus plural\` agus filleann sé an teaghrán cuí bunaithe ar `uimhre` agus an context\`. #### `ngettext_lazy(singular, plural, number)` #### `npgettext_lazy(context, singular, plural, number)` Mar an gcéanna leis na leaganacha neamh-leisciúla thuas, ach ag baint úsáide as forghní \Féach:ref: doiciméadú aistriúcháin leisciúil . #### `activate(language)` Faigheann sé an réad aistriúcháin do theanga ar leith agus gníomhaíonn sé é mar réad aistriúcháin reatha don snáithe reatha. #### `deactivate()` Díghníomhachtaíonn sé an réad aistriúcháin atá gníomhach faoi láthair ionas go réiteoidh glaonna breise i gcoinne an réad aistriúcháin #### `deactivate_all()` Déanann sé an réad aistriúcháin ghníomhach mar shampla NullTranslations () . Tá sé seo úsáideach nuair is mian linn go mbeadh aistriúcháin moillithe le feiceáil mar an teaghrán bunaidh ar chúis #### `override(language, deactivate=False)` Gníomhaíonn bainisteoir comhthéacs Python a úsáide:func: django.utils.translation.activate chun an réad aistriúcháin do theanga ar leith a fháil, é a ghníomhachtú mar réad aistriúcháin don snáithe reatha agus athghníomhachtaíonn sé an teanga ghníomhach roimhe seo ar imeacht. Go roghnach, féadfaidh sé an t-aistriúchán sealadach a dhíghníomhachtú ar imeacht le:func: django.utils.translation.deactivate má tá an argóint `deactivate` True\`. Má chuireann tú `None` mar argóint teanga, cuirtear cás NullTranslations () i ngníomh laistigh den chomhthéacs. Tá `override` inúsáidte mar mhaisitheoir feidhme freisin. #### `check_for_language(lang_code)` Seiceálann sé an bhfuil comhad teanga domhanda ann don chód teanga ar leith (m.sh. 'fr', 'pt\_br'). Úsáidtear é seo chun cinneadh a dhéanamh an bhfuil teanga a sholáthraíonn an úsáideoir ar fáil. `lang_code` has a maximum accepted length of 500 characters. `False` is returned if it exceeds this limit, before any language-file lookup. #### `get_language()` Tugann an cód teanga roghnaithe faoi láthair ar ais. Tugann `None` ar ais má dhíghníomhachtar aistriúcháin go sealadach (trí:func: deactivate\_all () \`nó nuair a chuirtear \`\`None\` chuig :func: override ()). #### `get_language_bidi()` Tugann leagan amach BiDi teanga roghnaithe: - `False` = leagan amach ar chlé go deis - `True` = leagan amach ar dheis go clé #### `get_language_from_request(request, check_path=False)` Déanann anailís ar an iarratas chun a fháil amach cén teanga a theastaíonn ón úsáideoir a thaispeáint. Ní chuirtear san áireamh ach teangacha atá liostaithe i socruithe. Má iarrann an t-úsáideoir fotheanga ina bhfuil príomhtheanga againn, seolfaimid an phríomhtheanga amach. Más é `check_path` `True`, seiceálann an fheidhm an URL iarrtha ar dtús cibé an dtosaíonn a chosán le cód teanga atá liostaithe sa socrú:setting: LANGUAGES. #### `get_supported_language_variant(lang_code, strict=False)` Tugann sé 'lang\_code\`\` ar ais má tá sé sa socrú: setting: LANGUAGES, b'fhéidir leagan níos cineálacha a roghnú. Mar shampla, cuirtear `es'` ar ais má tá `lang_code` `es-ar'` agus `` `es' `` in:setting: LANGUAGES ach níl `es-ar'`. Tá an fad uasta glactha le 500 carachtar ag `lang_code`. A: Exc: Ardaítear LookuPerror má sháraíonn `lang_code` an teorainn seo agus má tá ```docht ``True```, nó mura bhfuil aon leagan cineálach ann agus má tá `docht` False\`. Más é ```docht ``False``` (an réamhshocrú), féadfar leagan tír-shonrach a thabhairt ar ais nuair nach bhfaightear an cód teanga ná a leagan cineálach. Mar shampla, mura bhfuil ach `es-co'` in:setting: LANGUAGES, cuirtear é sin ar ais do `lang_code`s cosúil le `'es'` agus `es-ar'`. Ní chuirtear na cluichí sin ar ais má tá `strict=True`. Ardaithe:exc: LookuPerror mura bhfaightear aon rud. > **Changed in Django 4.2.15** > > I leaganacha níos sine, próiseáilíodh luachanna `lang_code` os cionn 500 carachtar gan a:exc: LookuPerror a ardú. #### `to_locale(language)` Tionann ainm teanga (en-us) ina ainm áitiúil (en\_US). #### `templatize(src)` Tionann teimpléad Django ina rud a thuigeann `xgettext`. Déanann sé amhlaidh trí na clibeanna aistriúcháin Django a aistriú go gcaighdeánacha feidhme `gettext`.