In order to make a Django project translatable, you have to add a minimal\nnumber of hooks to your Python code and templates. These hooks are called\ntranslation strings. They tell Django: "This text\nshould be translated into the end user's language, if a translation for this\ntext is available in that language." It's your responsibility to mark\ntranslatable strings; the system can only translate strings it knows about.
\nDjango then provides utilities to extract the translation strings into a\nmessage file. This file is a convenient way for translators to provide\nthe equivalent of the translation strings in the target language. Once the\ntranslators have filled in the message file, it must be compiled. This process\nrelies on the GNU gettext toolset.
\nOnce this is done, Django takes care of translating Web apps on the fly in each\navailable language, according to users' language preferences.
\nDjango's internationalization hooks are on by default, and that means there's a\nbit of i18n-related overhead in certain places of the framework. If you don't\nuse internationalization, you should take the two seconds to set\nUSE_I18N = False in your settings file. Then Django will\nmake some optimizations so as not to load the internationalization machinery.
Specify a translation string by using the function\ngettext(). It's convention to import this\nas a shorter alias, _, to save typing.
Di contoh ini, teks "Welcome to my site." ditandai sebagai deretan karakter terjemahan:
from django.http import HttpResponse\nfrom django.utils.translation import gettext as _\n\ndef my_view(request):\n output = _("Welcome to my site.")\n return HttpResponse(output)\nObviously, you could code this without using the alias. This example is\nidentical to the previous one:
\nfrom django.http import HttpResponse\nfrom django.utils.translation import gettext\n\ndef my_view(request):\n output = gettext("Welcome to my site.")\n return HttpResponse(output)\nTranslation works on computed values. This example is identical to the previous\ntwo:
\ndef my_view(request):\n words = ['Welcome', 'to', 'my', 'site.']\n output = _(' '.join(words))\n return HttpResponse(output)\nTerjemahan bekerja pada variabel. Kembali, ini adalah contoh yang mirip:
\ndef my_view(request):\n sentence = 'Welcome to my site.'\n output = _(sentence)\n return HttpResponse(output)\n(The caveat with using variables or computed values, as in the previous two\nexamples, is that Django's translation-string-detecting utility,\ndjango-admin makemessages, won't be able to find\nthese strings. More on makemessages later.)
The strings you pass to _() or gettext() can take placeholders,\nspecified with Python's standard named-string interpolation syntax. Example:
def my_view(request, m, d):\n output = _('Today is %(month)s %(day)s.') % {'month': m, 'day': d}\n return HttpResponse(output)\nThis technique lets language-specific translations reorder the placeholder\ntext. For example, an English translation may be "Today is November 26.",\nwhile a Spanish translation may be "Hoy es 26 de Noviembre." -- with the\nmonth and the day placeholders swapped.
For this reason, you should use named-string interpolation (e.g., %(day)s)\ninstead of positional interpolation (e.g., %s or %d) whenever you\nhave more than a single parameter. If you used positional interpolation,\ntranslations wouldn't be able to reorder placeholder text.
Since string extraction is done by the xgettext command, only syntaxes\nsupported by gettext are supported by Django. Python f-strings and\nJavaScript template strings are not yet supported by xgettext.
If you would like to give translators hints about a translatable string, you\ncan add a comment prefixed with the Translators keyword on the line\npreceding the string, e.g.:
def my_view(request):\n # Translators: This message appears on the home page only\n output = gettext("Welcome to my site.")\nThe comment will then appear in the resulting .po file associated with the\ntranslatable construct located below it and should also be displayed by most\ntranslation tools.
This also works in templates. See Komentar untuk penterjemah dalam cetakan for\nmore details.
\nUse the function django.utils.translation.gettext_noop() to mark a\nstring as a translation string without translating it. The string is later\ntranslated from a variable.
Use this if you have constant strings that should be stored in the source\nlanguage because they are exchanged over systems or users -- such as strings\nin a database -- but should be translated at the last possible point in time,\nsuch as when the string is presented to the user.
\nUse the function django.utils.translation.ngettext() to specify\npluralized messages.
ngettext() takes three arguments: the singular translation string, the\nplural translation string and the number of objects.
This function is useful when you need your Django application to be localizable\nto languages where the number and complexity of plural forms is\ngreater than the two forms used in English ('object' for the singular and\n'objects' for all the cases where count is different from one, irrespective\nof its value.)
Sebagai contoh:
\nfrom django.http import HttpResponse\nfrom django.utils.translation import ngettext\n\ndef hello_world(request, count):\n page = ngettext(\n 'there is %(count)d object',\n 'there are %(count)d objects',\n count) % {\n 'count': count,\n }\n return HttpResponse(page)\nIn this example the number of objects is passed to the translation\nlanguages as the count variable.
Note that pluralization is complicated and works differently in each language.\nComparing count to 1 isn't always the correct rule. This code looks\nsophisticated, but will produce incorrect results for some languages:
from django.utils.translation import ngettext\nfrom myapp.models import Report\n\ncount = Report.objects.count()\nif count == 1:\n name = Report._meta.verbose_name\nelse:\n name = Report._meta.verbose_name_plural\n\ntext = ngettext(\n 'There is %(count)d %(name)s available.',\n 'There are %(count)d %(name)s available.',\n count\n) % {\n 'count': count,\n 'name': name\n}\nDon't try to implement your own singular-or-plural logic, it won't be correct.\nIn a case like this, consider something like the following:
\ntext = ngettext(\n 'There is %(count)d %(name)s object available.',\n 'There are %(count)d %(name)s objects available.',\n count\n) % {\n 'count': count,\n 'name': Report._meta.verbose_name,\n}\nSometimes words have several meanings, such as "May" in English, which\nrefers to a month name and to a verb. To enable translators to translate\nthese words correctly in different contexts, you can use the\ndjango.utils.translation.pgettext() function, or the\ndjango.utils.translation.npgettext() function if the string needs\npluralization. Both take a context string as the first variable.
In the resulting .po file, the string will then appear as often as there are\ndifferent contextual markers for the same string (the context will appear on the\nmsgctxt line), allowing the translator to give a different translation for\neach of them.
Sebagai contoh:
\nfrom django.utils.translation import pgettext\n\nmonth = pgettext("month name", "May")\natau:
\nfrom django.db import models\nfrom django.utils.translation import pgettext_lazy\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=pgettext_lazy(\n 'help text for MyThing model', 'This is the help text'))\nakan muncul di berkas .po sebagai:
msgctxt "month name"\nmsgid "May"\nmsgstr ""\nContextual markers are also supported by the trans and\nblocktrans template tags.
Use the lazy versions of translation functions in\ndjango.utils.translation (easily recognizable by the lazy suffix in\ntheir names) to translate strings lazily -- when the value is accessed rather\nthan when they're called.
These functions store a lazy reference to the string -- not the actual\ntranslation. The translation itself will be done when the string is used in a\nstring context, such as in template rendering.
\nThis is essential when calls to these functions are located in code paths that\nare executed at module load time.
\nThis is something that can easily happen when defining models, forms and\nmodel forms, because Django implements these such that their fields are\nactually class-level attributes. For that reason, make sure to use lazy\ntranslations in the following cases:
\nverbose_name and help_text option valuesLink to this heading#For example, to translate the help text of the name field in the following\nmodel, do the following:
\nfrom django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=_('This is the help text'))\nYou can mark names of ForeignKey,\nManyToManyField or\nOneToOneField relationship as translatable by using\ntheir verbose_name options:
class MyThing(models.Model):\n kind = models.ForeignKey(\n ThingKind,\n on_delete=models.CASCADE,\n related_name='kinds',\n verbose_name=_('kind'),\n )\nJust like you would do in verbose_name you\nshould provide a lowercase verbose name text for the relation as Django will\nautomatically titlecase it when required.
It is recommended to always provide explicit\nverbose_name and\nverbose_name_plural options rather than\nrelying on the fallback English-centric and somewhat naïve determination of\nverbose names Django performs by looking at the model's class name:
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(_('name'), help_text=_('This is the help text'))\n\n class Meta:\n verbose_name = _('my thing')\n verbose_name_plural = _('my things')\nshort_description attribute valuesLink to this heading#For model methods, you can provide translations to Django and the admin site\nwith the short_description attribute:
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n kind = models.ForeignKey(\n ThingKind,\n on_delete=models.CASCADE,\n related_name='kinds',\n verbose_name=_('kind'),\n )\n\n def is_mouse(self):\n return self.kind.type == MOUSE_TYPE\n is_mouse.short_description = _('Is it a mouse?')\nThe result of a gettext_lazy() call can be used wherever you would use a\nstring (a str object) in other Django code, but it may not work with\narbitrary Python code. For example, the following won't work because the\nrequests library doesn't handle\ngettext_lazy objects:
body = gettext_lazy("I \\u2764 Django") # (unicode :heart:)\nrequests.post('https://example.com/send', data={'body': body})\nYou can avoid such problems by casting gettext_lazy() objects to text\nstrings before passing them to non-Django code:
requests.post('https://example.com/send', data={'body': str(body)})\nIf you don't like the long gettext_lazy name, you can just alias it as\n_ (underscore), like so:
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=_('This is the help text'))\nUsing gettext_lazy() and ngettext_lazy() to mark strings in models\nand utility functions is a common operation. When you're working with these\nobjects elsewhere in your code, you should ensure that you don't accidentally\nconvert them to strings, because they should be converted as late as possible\n(so that the correct locale is in effect). This necessitates the use of the\nhelper function described next.
When using lazy translation for a plural string ([u]n[p]gettext_lazy), you\ngenerally don't know the number argument at the time of the string\ndefinition. Therefore, you are authorized to pass a key name instead of an\ninteger as the number argument. Then number will be looked up in the\ndictionary under that key during string interpolation. Here's example:
from django import forms\nfrom django.utils.translation import ngettext_lazy\n\nclass MyForm(forms.Form):\n error_message = ngettext_lazy("You only provided %(num)d argument",\n "You only provided %(num)d arguments", 'num')\n\n def clean(self):\n # ...\n if error:\n raise forms.ValidationError(self.error_message % {'num': number})\nIf the string contains exactly one unnamed placeholder, you can interpolate\ndirectly with the number argument:
class MyForm(forms.Form):\n error_message = ngettext_lazy(\n "You provided %d argument",\n "You provided %d arguments",\n )\n\n def clean(self):\n # ...\n if error:\n raise forms.ValidationError(self.error_message % number)\nformat_lazy()Link to this heading#Python's str.format() method will not work when either the\nformat_string or any of the arguments to str.format()\ncontains lazy translation objects. Instead, you can use\ndjango.utils.text.format_lazy(), which creates a lazy object\nthat runs the str.format() method only when the result is included\nin a string. For example:
from django.utils.text import format_lazy\nfrom django.utils.translation import gettext_lazy\n...\nname = gettext_lazy('John Lennon')\ninstrument = gettext_lazy('guitar')\nresult = format_lazy('{name}: {instrument}', name=name, instrument=instrument)\nIn this case, the lazy translations in result will only be converted to\nstrings when result itself is used in a string (usually at template\nrendering time).
For any other case where you would like to delay the translation, but have to\npass the translatable string as argument to another function, you can wrap\nthis function inside a lazy call yourself. For example:
\nfrom django.utils.functional import lazy\nfrom django.utils.safestring import mark_safe\nfrom django.utils.translation import gettext_lazy as _\n\nmark_safe_lazy = lazy(mark_safe, str)\nDan lalu kemudian:
\nlazy_string = mark_safe_lazy(_("<p>My <strong>string!</strong></p>"))\nFungsi get_language_info() menyediakan informasi rinci tentang bahasa:
>>> from django.utils.translation import activate, get_language_info\n>>> activate('fr')\n>>> li = get_language_info('de')\n>>> print(li['name'], li['name_local'], li['name_translated'], li['bidi'])\nGerman Deutsch Allemand False\nThe name, name_local, and name_translated attributes of the\ndictionary contain the name of the language in English, in the language\nitself, and in your current active language respectively. The bidi\nattribute is True only for bi-directional languages.
The source of the language information is the django.conf.locale module.\nSimilar access to this information is available for template code. See below.
Translations in Django templates uses two template\ntags and a slightly different syntax than in Python code. To give your template\naccess to these tags, put {% load i18n %} toward the top of your template.\nAs with all template tags, this tag needs to be loaded in all templates which\nuse translations, even those templates that extend from other templates which\nhave already loaded the i18n tag.
transLink to this heading#The {% trans %} template tag translates either a constant string\n(enclosed in single or double quotes) or variable content:
<title>{% trans "This is the title." %}</title>\n<title>{% trans myvar %}</title>\nIf the noop option is present, variable lookup still takes place but the\ntranslation is skipped. This is useful when "stubbing out" content that will\nrequire translation in the future:
<title>{% trans "myvar" noop %}</title>\nInternally, inline translations use an\ngettext() call.
In case a template var (myvar above) is passed to the tag, the tag will\nfirst resolve such variable to a string at run-time and then look up that\nstring in the message catalogs.
It's not possible to mix a template variable inside a string within {% trans\n%}. If your translations require strings with variables (placeholders), use\n{% blocktrans %} instead.
If you'd like to retrieve a translated string without displaying it, you can\nuse the following syntax:
\n{% trans "This is the title" as the_title %}\n\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\nIn practice you'll use this to get a string you can use in multiple places in a\ntemplate or so you can use the output as an argument for other template tags or\nfilters:
\n{% trans "starting point" as start %}\n{% trans "end point" as end %}\n{% trans "La Grande Boucle" as race %}\n\n<h1>\n <a href="/" title="{% blocktrans %}Back to '{{ race }}' homepage{% endblocktrans %}">{{ race }}</a>\n</h1>\n<p>\n{% for stage in tour_stages %}\n {% cycle start end %}: {{ stage }}{% if forloop.counter|divisibleby:2 %}<br />{% else %}, {% endif %}\n{% endfor %}\n</p>\n{% trans %} also supports contextual markers\nusing the context keyword:
{% trans "May" context "month name" %}\nblocktransLink to this heading#Contrarily to the trans tag, the blocktrans tag allows you to mark\ncomplex sentences consisting of literals and variable content for translation\nby making use of placeholders:
{% blocktrans %}This string will have {{ value }} inside.{% endblocktrans %}\nTo translate a template expression -- say, accessing object attributes or\nusing template filters -- you need to bind the expression to a local variable\nfor use within the translation block. Examples:
\n{% blocktrans with amount=article.price %}\nThat will cost $ {{ amount }}.\n{% endblocktrans %}\n\n{% blocktrans with myvar=value|filter %}\nThis will have {{ myvar }} inside.\n{% endblocktrans %}\nYou can use multiple expressions inside a single blocktrans tag:
{% blocktrans with book_t=book|title author_t=author|title %}\nThis is {{ book_t }} by {{ author_t }}\n{% endblocktrans %}\nOther block tags (for example {% for %} or {% if %}) are not allowed\ninside a blocktrans tag.
If resolving one of the block arguments fails, blocktrans will fall back to\nthe default language by deactivating the currently active language\ntemporarily with the deactivate_all()\nfunction.
This tag also provides for pluralization. To use it:
\nDesignate and bind a counter value with the name count. This value will\nbe the one used to select the right plural form.
Specify both the singular and plural forms separating them with the\n{% plural %} tag within the {% blocktrans %} and\n{% endblocktrans %} tags.
Sebuah contoh:
\n{% blocktrans count counter=list|length %}\nThere is only one {{ name }} object.\n{% plural %}\nThere are {{ counter }} {{ name }} objects.\n{% endblocktrans %}\nA more complex example:
\n{% blocktrans with amount=article.price count years=i.length %}\nThat will cost $ {{ amount }} per year.\n{% plural %}\nThat will cost $ {{ amount }} per {{ years }} years.\n{% endblocktrans %}\nWhen you use both the pluralization feature and bind values to local variables\nin addition to the counter value, keep in mind that the blocktrans\nconstruct is internally converted to an ngettext call. This means the\nsame notes regarding ngettext variables\napply.
Reverse URL lookups cannot be carried out within the blocktrans and should\nbe retrieved (and stored) beforehand:
{% url 'path.to.view' arg arg2 as the_url %}\n{% blocktrans %}\nThis is a URL: {{ the_url }}\n{% endblocktrans %}\nIf you'd like to retrieve a translated string without displaying it, you can\nuse the following syntax:
\n{% blocktrans asvar the_title %}The title is {{ title }}.{% endblocktrans %}\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\nIn practice you'll use this to get a string you can use in multiple places in a\ntemplate or so you can use the output as an argument for other template tags or\nfilters.
\n{% blocktrans %} also supports contextual\nmarkers using the context keyword:
{% blocktrans with name=user.username context "greeting" %}Hi {{ name }}{% endblocktrans %}\nDukungan {% blocktrans %} fitur lain adalah pilihan trimmed. Pilihan ini akan memindahkan karakter baris baru dari awal dan akhir dari isi dari etiket {% blocktrans %}, ganti setiap ruang kosong pada awal dan akhir dari sebuah baris dan menggabungkan semua baris kedalam satu menggunakan karakter ruang kosong untuk memisahkan mereka. Ini sangat berguna untuk melekukkan isi dari etiket {% blocktrans %} tanpa memiliki karakter lekukan terakhir di masukan yang sesuai di berkas PO, yang membuat pengolahan terjemahan lebih mudah.
Untuk contoh, etiket {% blocktrans %} berikut:
{% blocktrans trimmed %}\n First sentence.\n Second paragraph.\n{% endblocktrans %}\nwill result in the entry "First sentence. Second paragraph." in the PO file,\ncompared to "\\n First sentence.\\n Second sentence.\\n", if the trimmed\noption had not been specified.
Just like with Python code, these notes for\ntranslators can be specified using comments, either with the comment\ntag:
{% comment %}Translators: View verb{% endcomment %}\n{% trans "View" %}\n\n{% comment %}Translators: Short intro blurb{% endcomment %}\n<p>{% blocktrans %}A multiline translatable\nliteral.{% endblocktrans %}</p>\nor with the {# ... #} one-line comment constructs:
{# Translators: Label of a button that triggers search #}\n<button type="submit">{% trans "Go" %}</button>\n\n{# Translators: This is a text of the base template #}\n{% blocktrans %}Ambiguous translatable block of text{% endblocktrans %}\nJika anda ingin memilih sebuah bahasa dalam sebuah cetakan, anda dapat menggunakan etiket cetakan language:
{% load i18n %}\n\n{% get_current_language as LANGUAGE_CODE %}\n<!-- Current language: {{ LANGUAGE_CODE }} -->\n<p>{% trans "Welcome to our page" %}</p>\n\n{% language 'en' %}\n {% get_current_language as LANGUAGE_CODE %}\n <!-- Current language: {{ LANGUAGE_CODE }} -->\n <p>{% trans "Welcome to our page" %}</p>\n{% endlanguage %}\nWhile the first occurrence of "Welcome to our page" uses the current language,\nthe second will always be in English.
\nMenambahkan terjemahan ke JavaScript menimbulkan beberapa masalah:
\nKode JavaScript tidak mempunyai akses ke penerapan gettext.
Kode JavaScript tidak mempunyai akses ke berkas .po or .mo; mereka butuh untuk dikirimkan oleh peladen.
Katalog terjemahan untuk JavaScript harus disimpan sekecil mungkin.
Django provides an integrated solution for these problems: It passes the\ntranslations into JavaScript, so you can call gettext, etc., from within\nJavaScript.
The main solution to these problems is the following JavaScriptCatalog view,\nwhich generates a JavaScript code library with functions that mimic the\ngettext interface, plus an array of translation strings.
JavaScriptCatalogLink to this heading#A view that produces a JavaScript code library with functions that mimic\nthe gettext interface, plus an array of translation strings.
Attributes
\nTranslation domain containing strings to add in the view output.\nDefaults to 'djangojs'.
A list of application names among\ninstalled applications. Those apps should contain a locale\ndirectory. All those catalogs plus all catalogs found in\nLOCALE_PATHS (which are always included) are merged into one\ncatalog. Defaults to None, which means that all available\ntranslations from all INSTALLED_APPS are provided in the\nJavaScript output.
Example with default values:
\nfrom django.views.i18n import JavaScriptCatalog\n\nurlpatterns = [\n path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n]\nExample with custom packages:
\nurlpatterns = [\n path('jsi18n/myapp/',\n JavaScriptCatalog.as_view(packages=['your.app.label']),\n name='javascript-catalog'),\n]\nIf your root URLconf uses i18n_patterns(),\nJavaScriptCatalog must also be wrapped by i18n_patterns() for the\ncatalog to be correctly generated.
Example with i18n_patterns():
from django.conf.urls.i18n import i18n_patterns\n\nurlpatterns = i18n_patterns(\n path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n)\nThe precedence of translations is such that the packages appearing later in the\npackages argument have higher precedence than the ones appearing at the\nbeginning. This is important in the case of clashing translations for the same\nliteral.
If you use more than one JavaScriptCatalog view on a site and some of them\ndefine the same strings, the strings in the catalog that was loaded last take\nprecedence.
Untuk menggunakan katalog, cukup tarik di tulisan dibangkitkan dinamis seperti ini:
\n<script type="text/javascript" src="{% url 'javascript-catalog' %}"></script>\nThis uses reverse URL lookup to find the URL of the JavaScript catalog view.\nWhen the catalog is loaded, your JavaScript code can use the following methods:
\ngettext
ngettext
interpolate
get_format
gettext_noop
pgettext
npgettext
pluralidx
gettextLink to this heading#The gettext function behaves similarly to the standard gettext\ninterface within your Python code:
document.write(gettext('this is to be translated'));\nngettextLink to this heading#The ngettext function provides an interface to pluralize words and\nphrases:
var object_count = 1 // or 0, or 2, or 3, ...\ns = ngettext('literal for the singular case',\n 'literal for the plural case', object_count);\ninterpolateLink to this heading#The interpolate function supports dynamically populating a format string.\nThe interpolation syntax is borrowed from Python, so the interpolate\nfunction supports both positional and named interpolation:
Penempatan penambahan: obj mengandung obyek Senarai JavaScript yang unsur-unsurnya kemudian berurutan ditambahkan dalam palceholder fmt mereka yang sesuai dalam urutan sama mereka muncul. Sebagai contoh:
fmts = ngettext('There is %s object. Remaining: %s',\n 'There are %s objects. Remaining: %s', 11);\ns = interpolate(fmts, [11, 20]);\n// s is 'There are 11 objects. Remaining: 20'\nNamed interpolation: This mode is selected by passing the optional\nboolean named parameter as true. obj contains a JavaScript\nobject or associative array. For example:
d = {\n count: 10,\n total: 50\n};\n\nfmts = ngettext('Total: %(total)s, there is %(count)s object',\n'there are %(count)s of a total of %(total)s objects', d.count);\ns = interpolate(fmts, d, true);\nYou shouldn't go over the top with string interpolation, though: this is still\nJavaScript, so the code has to make repeated regular-expression substitutions.\nThis isn't as fast as string interpolation in Python, so keep it to those\ncases where you really need it (for example, in conjunction with ngettext\nto produce proper pluralizations).
get_formatLink to this heading#Fungsi get_format mempunyai akses ke pengaturan pembentukan i18n terkonfigurasi dan dapat mengambil bentuk string untuk nama pengaturan yang diberikan:
document.write(get_format('DATE_FORMAT'));\n// 'N j, Y'\nItu mempunyai akses pada pengaturan berikut:
\nIni berguna untuk merawat ketetapan pembentukan dengan nilai-nilai dibangun-Python.
\ngettext_noopLink to this heading#Ini menandingin fungsi gettext tetapi tidak melakukan apapun, mengembalikan apapun dilewatkan ke itu:
document.write(gettext_noop('this will not be translated'));\nIni adalah berguna untuk memberhentikan bagian-bagian dari kode akan butuh diterjemahkan di masa akan datang.
\npgettextLink to this heading#Fungsi pgettext berperilaku seperti ragam Python (pgettext()), menyediakan kata terjemahan kontekstual:
document.write(pgettext('month name', 'May'));\nnpgettextLink to this heading#Fungsi npgettext juga berperilaku seperti ragam Python (npgettext()), menyediakan menjamakkan kata terjemahan kontekstual:
document.write(npgettext('group', 'party', 1));\n// party\ndocument.write(npgettext('group', 'party', 2));\n// parties\npluralidxLink to this heading#Fungsi pluralidx bekerja dalam cara sama pada penyaring cetakan pluralize, menentukan jika count diberikan harus menggunakan bentuk jamak dari sebuah kata atau tidak:
document.write(pluralidx(0));\n// true\ndocument.write(pluralidx(1));\n// false\ndocument.write(pluralidx(2));\n// true\nDalam kasis paling sederhana, jika tidak ada penyesuaian penjamakan dibutuhkan, ini mengembalikan false untuk integer 1 dan true untuk semua angka-angka lain.
Bagaimanapun, penjamakan tidak sesederhana ini dalam semua bahasa. Jika bahasa tidak mendukung penjamakan, sebuah nilai kosong disediakan.
\nTambahannya, jika ada aturan-aturan rumit sekitar penjamakan, tampilan katalog akan membangun sebuah penyataan bersyarat. Ini akan menilai salah satu nilai True (harus jamak) atau false (harus tidak jamak).
JSONCatalogLink to this heading#Untuk menggunakan pustaka sisi-klien lain untuk menangani terjemahan, anda mungkin ingin mengambil keuntungan dari tampilan JSONCatalog. Itu mirip pada JavaScriptCatalog tetapi mengembalikan sebuah tanggapan JSON.
Lihat dokumentasi untuk JavaScriptCatalog untuk belajar tentang kemungkinan nilai-nilai dan penggunaan dari atribut-atribut domain dan packages.
Bentuk tanggapan sebagai berikut:
\n{\n "catalog": {\n # Translations catalog\n },\n "formats": {\n # Language formats for date, time, etc.\n },\n "plural": "..." # Expression for plural forms, or null.\n}\nTampilan beragam i18n JavaScript/JSON membangkitkan katalog dari berkas-berkas .mo pada setiap permintaan. Sejak itu mengeluarkan sebuah ketetapan, setidaknya untuk versi diberikan dari sebuah situs, itu adalah calon bagus untuk caching.
Caching sisi-peladen akan mengurangi beban CPU. Itu sangat mudah diterapkan dengan penghias cache_page(). Untuk memicu ketidakabsahan cache ketika terjemahan anda berubah, sediakan awalan kunci versi-berdiri-sendiri, seperti ditunjukkan dalam contoh dibawah atau tampilan peta pada URL versi-berdiri-sendiri:
from django.views.decorators.cache import cache_page\nfrom django.views.i18n import JavaScriptCatalog\n\n# The value returned by get_version() must change when translations change.\nurlpatterns = [\n path('jsi18n/',\n cache_page(86400, key_prefix='js18n-%s' % get_version())(JavaScriptCatalog.as_view()),\n name='javascript-catalog'),\n]\nCaching sisi-klien akan menyimpan lebar pita dan membuat situs anda dimuat lebih cepat. Jika anda sedang menggunakan ETag (ConditionalGetMiddleware), anda siap dicakupi. Sebaliknya, anda dapat memberlakukan conditional decorators 1. Dalam contoh berikut, cache tidak berlaku ketika anda memulai kembali peladen aplikasi anda:
from django.utils import timezone\nfrom django.views.decorators.http import last_modified\nfrom django.views.i18n import JavaScriptCatalog\n\nlast_modified_date = timezone.now()\n\nurlpatterns = [\n path('jsi18n/',\n last_modified(lambda req, **kw: last_modified_date)(JavaScriptCatalog.as_view()),\n name='javascript-catalog'),\n]\nAnda dapat bahkan pra-membangkitkan katalog JavaScript sebagai bagian dari prosedur pegembangan anda dan melayani itu sebagai berkas tetap. Teknik radikal ini adalah diterapkan dalam django-statici18n.
\nDjango menyediakan dua mekanisme pada pola URL internasionalisasi:
\nMenambahkan awalan bahasa pada akar dari pola URL untuk membuat itu memungkinkan untuk LocaleMiddleware untuk mengenali bahasa untuk diaktifkan dari URL diminta.
Membuat pola URL mereka sendiri dapat diterjemahkan melalui fungsi django.utils.translation.gettext_lazy().
Fungsi ini dapat digunakan dalam URLconf akar dan Django akan otomatis menambahkan kode bahasa aktif saat ini pada semua pola URL ditentukan dalam i18n_patterns().
Mengatur prefix_default_language menjadi False memindahkan awalan dari bahasa awalan (LANGUAGE_CODE). Ini dapat berguna ketika menambahkan terjemahan pada situs yang ada sehingga URL saat ini tidak akan berubah.
Contoh pola URL:
\nfrom django.conf.urls.i18n import i18n_patterns\nfrom django.urls import include, url\n\nfrom about import views as about_views\nfrom news import views as news_views\nfrom sitemap.views import sitemap\n\nurlpatterns = [\n path('sitemap.xml', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n path('', news_views.index, name='index'),\n path('category/<slug:slug>/', news_views.category, name='category'),\n path('<slug:slug>/', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n path('about/', about_views.main, name='about'),\n path('news/', include(news_patterns, namespace='news')),\n)\nSetelah menentukan pola URL ini, Django akan otomatis menambahkan awalan bahasa ke pola URL yang telah ditambahkan oleh fungsi i18n_patterns. Contoh:
>>> from django.urls import reverse\n>>> from django.utils.translation import activate\n\n>>> activate('en')\n>>> reverse('sitemap-xml')\n'/sitemap.xml'\n>>> reverse('news:index')\n'/en/news/'\n\n>>> activate('nl')\n>>> reverse('news:detail', kwargs={'slug': 'news-slug'})\n'/nl/news/news-slug/'\nDengan prefix_default_language=False dan LANGUAGE_CODE='en', URL akan menjadi:
>>> activate('en')\n>>> reverse('news:index')\n'/news/'\n\n>>> activate('nl')\n>>> reverse('news:index')\n'/nl/news/'\nPola URL dapat juga ditandai dapat diterjemahkan menggunakan fungsi gettext_lazy(). Contoh:
from django.conf.urls.i18n import i18n_patterns\nfrom django.urls import include, path\nfrom django.utils.translation import gettext_lazy as _\n\nfrom about import views as about_views\nfrom news import views as news_views\nfrom sitemaps.views import sitemap\n\nurlpatterns = [\n path('sitemap.xml', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n path('', news_views.index, name='index'),\n path(_('category/<slug:slug>/'), news_views.category, name='category'),\n path('<slug:slug>/', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n path(_('about/'), about_views.main, name='about'),\n path(_('news/'), include(news_patterns, namespace='news')),\n)\nSetelah anda telah membuat terjemahan, fungsi reverse() akan mengembalikan URL dalam bahasa aktif. Contoh:
>>> from django.urls import reverse\n>>> from django.utils.translation import activate\n\n>>> activate('en')\n>>> reverse('news:category', kwargs={'slug': 'recent'})\n'/en/news/category/recent/'\n\n>>> activate('nl')\n>>> reverse('news:category', kwargs={'slug': 'recent'})\n'/nl/nieuws/categorie/recent/'\nJika URL lokal mendapatkan terbalik dalam cetakan mereka selalu menggunakan bahasa saat ini. Untuk menautkan ke sebuah URL dalam bahasa lain gunakan etiket cetakan language. Itu mengadakan bahasa yang diberikan dalam bagian cetakan tertutup:
{% load i18n %}\n\n{% get_available_languages as languages %}\n\n{% trans "View this category in:" %}\n{% for lang_code, lang_name in languages %}\n {% language lang_code %}\n <a href="{% url 'category' slug=category.slug %}">{{ lang_name }}</a>\n {% endlanguage %}\n{% endfor %}\nEtiket language mengharapkan kode bahasa sebagai hanya argumen.
Setelah harfiah string dari sebuah aplikasi telah dietiketkan untuk terjemahan akhir, terjemahan itu sendiri butuh ditulis (atau diambil). Ini adalah bagaimana itu bekerja.
\nlangkah pertama adalah membuat sebuah message file untuk bahasa baru. Sebuah berkas pesan adalah sebuah berkas teks-polos, mewakili bahasa tunggal, yang mengandung semua string terjemahan tersedia dan bagaimana mereka harus dibawakan dalam bahasa diberikan. Berkas-berkas pesan mempunyai ekstensi berkas .po.
Django datang dengan sebuah alat, django-admin makemessages 1, yang mengotomatiskan pembuatan dan perawatan dari berkas-berkas ini.
Untuk membuat atau memperbaharui sebuah berkas pesan, jalankan perintah ini:
\ndjango-admin makemessages -l de\n...dimana de adalah locale name untuk berkas pesan anda ingin buat. Sebagai contoh, pt_BR untuk Brasil Portugis, de_AT untuk Austria Jerman atau id untuk Indonesia.
Tulisan ini harus berjalan dari satu atau dua tempat:
\nDirektori akar untuk proyek Django anda (satu yang mengandung manage.py).
Direktori akar dari satu dari aplikasi Django anda.
Tulisan berjalan terhadap pohon sumber proyek anda atau pohon sumber aplikasi anda dan menarik semua string ditandai untuk terjemahan (lihat Bagaimana Django menemukan terjemahan dan pastikan LOCALE_PATHS dikonfigurasi dengan benar). Itu membuat (atau memperbaharui) sebuah berkas pesan dalam direktori locale/LANG/LC_MESSAGES. Dalam contoh de, berkas akan berupa locale/de/LC_MESSAGES/django.po.
Ketika anda menjalankan makemessages dari direktori akar dari proyek anda, string dikeluarkan akan secara otomatis disebarkan pada berkas-berkas pesan yang sesuai. Yaitu, string dikeluarkan dari sebuah berkas dari sebuah aplikasi mengandung direktori locale akan masuk dalam berkas pesan dibawah direktori itu. Sebuah string dikeluarkan dari sebuah berkas dari sebuah aplikasi tanpa direktori locale akan salah satu masuk dalam berkas pesan dibawah direktori didaftar pertama dalam LOCALE_PATHS atau akan membangkitkan sebuah kesalahan jika LOCALE_PATHS adalah kosong.
Secara awalan django-admin makemessages 1 menguji setiap berkas yang mempunyai ekstensi berkas .html, .txt atau .py. Jika anda ingin menimpa awalan itu, gunakan pilihan --extension 2 atau -e untuk menentukan ekstensi berkas untuk diuji:
django-admin makemessages -l de -e txt\nMmeisahkan banyak ekstensi dengan koma dan/atau menggunakan -e atau --extension berkali-kali:
django-admin makemessages -l de -e html,txt -e xml\nThe format of .po files is straightforward. Each .po file contains a\nsmall bit of metadata, such as the translation maintainer's contact\ninformation, but the bulk of the file is a list of messages -- simple\nmappings between translation strings and the actual translated text for the\nparticular language.
Sebagai contoh, jika aplikasi Django anda mengandung string terjemahan untuk teks "Welcome to my site.", seperti itu:
_("Welcome to my site.")\n...kemudian django-admin makemessages 1 akan membuat sebuah berkas .po mengandung potongan berikut -- sebuah pesan:
#: path/to/python/module.py:23\nmsgid "Welcome to my site."\nmsgstr ""\nPenjelasan cepat:
\nmsgid adalah string terjemahan, yang muncul dalam sumber. Jangan rubah itu.
msgstr adalah dimana anda menaruh terjemahan bahasa-khusus. Itu mulai kosong, jadi itu adalah tanggungjawab anda merubah itu. pastikan anda menjaga kutipan disekitar terjemahan anda.
Sebagai sebuah kenyamanan, setiap pesan termasuk, dalam bentuk dari baris komentar diawali dengan # dan bertempat diatas baris msgid, nama berkas dan nomor baris dari mana string terjemahan telah dikumpulkan sedikit demi sedikit.
Pesan-pesan panjang adalah kasus khusus. Ada, string pertama secara langsung setelah msgstr (atau msgid) adalah string kosong. Kemudian isi itu sendiri akan ditulis terhadap sedikit baris selanjutnya sebagai satu string per baris. String-string tersebut secara langsung disatukan. Jangan lupa buntutan ruang kosong dalam string; jika tidak, mereka akan dilekatkan bersama-sama tanpa ruang kosong!
Untuk menguji kembali semua kode sumber da cetakan untuk string terjemahan baru dan memperbaharui semua berkas pesan untuk semua bahasa, jalankan ini:
\ndjango-admin makemessages -a\nSetelah anda membuat berkas pesan anda -- dan setiap kali anda membuat perubahan ke itu -- anda akan butuh menyusun itu menjadi bentuk lebih efesien, untuk digunakan oleh gettext. Lakukan ini dengan alat django-admin compilemessages 1.
Alat ini berjalan terhadap semua berkas .po tersedia dan membuat berkas .mo, yang adalah berkas biner dioptimalkan untu digunakan oleh gettext. Dalam direktori sama dari mana anda menjalankan django-admin makemessages 1, jalankan django-admin compilemessages 2 seperti ini:
django-admin compilemessages\nItu dia, terjemahan anda siap digunakan.
\n\n\ngettext() tidak benar mengenali python-format dalam string-string dengan tanda persenLink to this heading#In some cases, such as strings with a percent sign followed by a space and a\nstring conversion type (e.g.\n_("10% interest")), gettext() incorrectly\nflags strings with python-format.
If you try to compile message files with incorrectly flagged strings, you'll\nget an error message like number of format specifications in 'msgid' and\n'msgstr' does not match or 'msgstr' is not a valid Python format string,\nunlike 'msgid'.
Untuk memecahkan ini, anda dapat meloloskan tanda persen dengan menambahkan tanda persen kedua:
\nfrom django.utils.translation import gettext as _\noutput = _("10%% interest")\nAtau anda dapat menggunakan no-python-format sehingga semua tanda persen diperlakukan sebagai harfiah.
# xgettext:no-python-format\noutput = _("10% interest")\nYou create and update the message files the same way as the other Django message\nfiles -- with the django-admin makemessages tool.\nThe only difference is you need to explicitly specify what in gettext parlance\nis known as a domain in this case the djangojs domain, by providing a -d\ndjangojs parameter, like this:
django-admin makemessages -d djangojs -l de\nThis would create or update the message file for JavaScript for German. After\nupdating message files, just run django-admin compilemessages the same way as you do with normal Django message files.
gettext pada WindowsLink to this heading#This is only needed for people who either want to extract message IDs or compile\nmessage files (.po). Translation work itself just involves editing existing\nfiles of this type, but if you want to create your own message files, or want to\ntest or compile a changed message file, download a precompiled binary\ninstaller.
You may also use gettext binaries you have obtained elsewhere, so long as\nthe xgettext --version command works properly. Do not attempt to use Django\ntranslation utilities with a gettext package if the command xgettext\n--version entered at a Windows command prompt causes a popup window saying\n"xgettext.exe has generated errors and will be closed by Windows".
makemessagesLink to this heading#Jika anda ingin melewatkan parameter tambahan pada xgettext, anda butuh membuat perintah makemessages penyesuaian dan menimpa atribut xgettext_options nya:
from django.core.management.commands import makemessages\n\nclass Command(makemessages.Command):\n xgettext_options = makemessages.Command.xgettext_options + ['--keyword=mytrans']\nJika anda butuh lebih keluwesan, anda dapat juga menambahkan argumen baru ke perintah perintah makemessages anda:
from django.core.management.commands import makemessages\n\nclass Command(makemessages.Command):\n\n def add_arguments(self, parser):\n super().add_arguments(parser)\n parser.add_argument(\n '--extra-keyword',\n dest='xgettext_keywords',\n action='append',\n )\n\n def handle(self, *args, **options):\n xgettext_keywords = options.pop('xgettext_keywords')\n if xgettext_keywords:\n self.xgettext_options = (\n makemessages.Command.xgettext_options[:] +\n ['--keyword=%s' % kwd for kwd in xgettext_keywords]\n )\n super().handle(*args, **options)\nset_languageLink to this heading#As a convenience, Django comes with a view, django.views.i18n.set_language(),\nthat sets a user's language preference and redirects to a given URL or, by default,\nback to the previous page.
Aktifkan tampilan ini dengan menambahkan baris berikut ke URLconf anda:
\npath('i18n/', include('django.conf.urls.i18n')),\n(Catat bahwa contoh ini membuat tampilan tersedia pada /i18n/setlang/.)
The view expects to be called via the POST method, with a language\nparameter set in request. If session support is enabled, the view\nsaves the language choice in the user's session. Otherwise, it saves the\nlanguage choice in a cookie that is by default named django_language.\n(The name can be changed through the LANGUAGE_COOKIE_NAME setting.)
After setting the language choice, Django looks for a next parameter in the\nPOST or GET data. If that is found and Django considers it to be a safe\nURL (i.e. it doesn't point to a different host and uses a safe scheme), a\nredirect to that URL will be performed. Otherwise, Django may fall back to\nredirecting the user to the URL from the Referer header or, if it is not\nset, to /, depending on the nature of the request:
Untuk permintaan AJAX, fallback akan dialkukan hanya jika parameter next telah disetel. Sebaliknya sebuah kode keadaan 204 (Tidak ada Isi) akan dikembalikan.
Untuk permintaan bukan-AJAX, fallback akan selalu dilakukan.
Ini adalah contoh kode cetakan HTML:
\n{% load i18n %}\n\n<form action="{% url 'set_language' %}" method="post">{% csrf_token %}\n <input name="next" type="hidden" value="{{ redirect_to }}" />\n <select name="language">\n {% get_current_language as LANGUAGE_CODE %}\n {% get_available_languages as LANGUAGES %}\n {% get_language_info_list for LANGUAGES as languages %}\n {% for language in languages %}\n <option value="{{ language.code }}"{% if language.code == LANGUAGE_CODE %} selected{% endif %}>\n {{ language.name_local }} ({{ language.code }})\n </option>\n {% endfor %}\n </select>\n <input type="submit" value="Go" />\n</form>\nDalam contoh ini, Django mencari URL dari halaman pada dimana pengguna akan dialihkan dalam variabel konteks redirect_to.
Anda mungkin ingin menyetel bahasa aktif untuk sesi saat ini secara jelas. Mungkin pilihan bahasa pengguna diambil dari sistem lain, sebagai contoh. Anda telah diperkenalkan pada django.utils.translation.activate(). Yang memberlakukan ke hanya rangkaian saat ini. Untuk bertahan bahasa untuk seluruh sesi, juga rubah LANGUAGE_SESSION_KEY dalam sesi:
from django.utils import translation\nuser_language = 'fr'\ntranslation.activate(user_language)\nrequest.session[translation.LANGUAGE_SESSION_KEY] = user_language\nAnda biasaya ingin melakukan menggunakan kedua: django.utils.translation.activate() akan merubah bahasa ke rangkaian ini, dan merubah sesi membuat pilihan ini tetap ada di permintaan akan datang.
Jika anda tidak menggunakan sesi, bahasa akan terus ada dalam sebuah cookie, yang namanya dikonfigurasi dalam LANGUAGE_COOKIE_NAME. Sebagai contoh:
from django.conf import settings\nfrom django.http import HttpResponse\nfrom django.utils import translation\nuser_language = 'fr'\ntranslation.activate(user_language)\nresponse = HttpResponse(...)\nresponse.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)\nWhile Django provides a rich set of i18n tools for use in views and templates,\nit does not restrict the usage to Django-specific code. The Django translation\nmechanisms can be used to translate arbitrary texts to any language that is\nsupported by Django (as long as an appropriate translation catalog exists, of\ncourse). You can load a translation catalog, activate it and translate text to\nlanguage of your choice, but remember to switch back to original language, as\nactivating a translation catalog is done on per-thread basis and such change\nwill affect code running in the same thread.
\nSebagai contoh:
\nfrom django.utils import translation\n\ndef welcome_translated(language):\n cur_language = translation.get_language()\n try:\n translation.activate(language)\n text = translation.gettext('welcome')\n finally:\n translation.activate(cur_language)\n return text\nMemanggil fungsi ini dengan nilai 'de' akan memberikan anda "Willkommen", tanpa memperhatikan dari LANGUAGE_CODE dan bahasa disetel oleh middleware.
Fungsi-fungsi untuk minat tertentu adalah django.utils.translation.get_language() yang mengembalikan bahasa digunakan dalam thread saat ini, django.utils.translation.activate() yang mengaktifkan sebuah katalog terjemahan untuk thread saat ini, dan django.utils.translation.check_for_language() yang akan memeriksa jika bahasa diberikan adalah didukung oleh Django.
Untuk membantu menulis lebih kode ringkas, ada juga sebuah pengelola konteks django.utils.translation.override() yang menyimpan bahasa sat ini pada saat masuk dan menyimpan kembali itu pada saat keluar. Dengan itu, contoh diatas menjadi:
from django.utils import translation\n\ndef welcome_translated(language):\n with translation.override(language):\n return translation.gettext('welcome')\nDjango's translation machinery uses the standard gettext module that comes\nwith Python. If you know gettext, you might note these specialties in the\nway Django does translation:
The string domain is django or djangojs. This string domain is\nused to differentiate between different programs that store their data\nin a common message-file library (usually /usr/share/locale/). The\ndjango domain is used for Python and template translation strings\nand is loaded into the global translation catalogs. The djangojs\ndomain is only used for JavaScript translation catalogs to make sure\nthat those are as small as possible.
Django tidak menggunakan xgettext sendiri. Itu menggunakan Python dibungkus disekitar xgettext dan msgfmt. Ini kebanyakan untuk kenyamanan.
Ketika anda telah menyiapkan terjemahan anda -- atau, jika anda hanya ingin menggunakan terjemahan yang datang dengan Django -- anda hanya butuh mengaktifkan terjemahan untuk aplikasi anda.
\nDbelakang layar, Django mempunyai model yang sagat elastis dari memutuskan bahasa mana harus digunakan -- pemasangan-lebar, untuk pengguna tertentu, atau keduanya.
\nUntuk menyetel sebuah pilihan bahasa pemasangan-luas, setel LANGUAGE_CODE. Django menggunakan bahasa ini sebagai terjemahan awalan -- usaha akhir jika tidak ada terjemahan yang cocok ditemukan melalui satu dari metode-metode dengan middleware lokal (lihat dibawah).
Jika yang anda inginkan adalah menjalankan Django dengan bahasa asli anda semua anda butuhkan untuk lakukan adalah menyetel LANGUAGE_CODE dan memastikan message files 1 sesuai dan versi tersusun mereka (.mo) ada.
Jika anda ingin membiarkan setiap pengguna perorangan menentukan bahasa mana mereka pilih, kemudian anda juga butuh menggunakan LocaleMiddleware. LocaleMiddleware mengadakan pilihan bahasa berdasarkan pada data dari permintaan. Itu menyesuaikan isi untuk setiap pengguna.
Untuk menggunakan LocaleMiddleware, tambah 'django.middleware.locale.LocaleMiddleware' ke pengaturan MIDDLEWARE anda. Karena urutan middleware penting, ikuti panduan berikut:
Pastikan itu adalah satu dari middleware pertama dipasang.
It should come after SessionMiddleware, because LocaleMiddleware\nmakes use of session data. And it should come before CommonMiddleware\nbecause CommonMiddleware needs an activated language in order\nto resolve the requested URL.
Jika anda menggunakan CacheMiddleware, taruh LocaleMiddleware setelah itu.
Sebagai contoh, MIDDLEWARE anda mungkin terlihat seperti ini:
MIDDLEWARE = [\n 'django.contrib.sessions.middleware.SessionMiddleware',\n 'django.middleware.locale.LocaleMiddleware',\n 'django.middleware.common.CommonMiddleware',\n]\n(Untuk lebih pada middleware, lihat middleware documentation 1.)
\nLocaleMiddleware mencoba menentukan pilihan bahasa pengguna dengan mengikuti algoritma ini:
First, it looks for the language prefix in the requested URL. This is\nonly performed when you are using the i18n_patterns function in your\nroot URLconf. See Internasionalisasi: dalam pola URL for more information\nabout the language prefix and how to internationalize URL patterns.
Failing that, it looks for the LANGUAGE_SESSION_KEY\nkey in the current user's session.
Failing that, it looks for a cookie.
\nNama dari cookie digunakan adalah disetel oleh pengaturan LANGUAGE_COOKIE_NAME. (Nama awalan adalah django_language.)
Failing that, it looks at the Accept-Language HTTP header. This\nheader is sent by your browser and tells the server which language(s) you\nprefer, in order by priority. Django tries each language in the header\nuntil it finds one with available translations.
Failing that, it uses the global LANGUAGE_CODE setting.
Catatan:
\nIn each of these places, the language preference is expected to be in the\nstandard language format, as a string. For example,\nBrazilian Portuguese is pt-br.
If a base language is available but the sublanguage specified is not,\nDjango uses the base language. For example, if a user specifies de-at\n(Austrian German) but Django only has de available, Django uses\nde.
Only languages listed in the LANGUAGES setting can be selected.\nIf you want to restrict the language selection to a subset of provided\nlanguages (because your application doesn't provide all those languages),\nset LANGUAGES to a list of languages. For example:
LANGUAGES = [\n ('de', _('German')),\n ('en', _('English')),\n]\nContoh-contoh ini membatasi bahasa-bahasa yang tersedia untuk pemilihan otomatis pada Jerman dan Inggris (dan subbahasa apapun, seperti de-ch atau en-us).
\nIf you define a custom LANGUAGES setting, as explained in the\nprevious bullet, you can mark the language names as translation strings\n-- but use gettext_lazy() instead of\ngettext() to avoid a circular import.
Ini adalah contoh sebuah berkas pengaturan:
\nfrom django.utils.translation import gettext_lazy as _\n\nLANGUAGES = [\n ('de', _('German')),\n ('en', _('English')),\n]\nOnce LocaleMiddleware determines the user's preference, it makes this\npreference available as request.LANGUAGE_CODE for each\nHttpRequest. Feel free to read this value in your view\ncode. Here's a simple example:
from django.http import HttpResponse\n\ndef hello_world(request, count):\n if request.LANGUAGE_CODE == 'de-at':\n return HttpResponse("You prefer to read Austrian German.")\n else:\n return HttpResponse("You prefer to read another language.")\nCatat bahwa, dengan terjemahan tetap (tanpa-middleware), bahasa di settings.LANGUAGE_CODE, selagi dengan terjemahan dinamis (middleware), itu di request.LANGUAGE_CODE.
At runtime, Django builds an in-memory unified catalog of literals-translations.\nTo achieve this it looks for translations by following this algorithm regarding\nthe order in which it examines the different file paths to load the compiled\nmessage files (.mo) and the precedence of multiple\ntranslations for the same literal:
The directories listed in LOCALE_PATHS have the highest\nprecedence, with the ones appearing first having higher precedence than\nthe ones appearing later.
Then, it looks for and uses if it exists a locale directory in each\nof the installed apps listed in INSTALLED_APPS. The ones\nappearing first have higher precedence than the ones appearing later.
Akhirnya, terjemahan dasar disediakan-Django dalam django/conf/locale digunakan sebagai sebuah fallback.
In all cases the name of the directory containing the translation is expected to\nbe named using locale name notation. E.g. de, pt_BR, es_AR,\netc.
Cara ini, anda dapat menulis aplikasi yang menyertakan terjemahan mereka sendiri, dan anda dapat menimpa terjemahan dasar dalam proyek anda. Atau, anda dapat cukup membangun proyek besar dari beberapa aplikasi dan menaruh semua terjemahan kedalam berkas pesan umum besar ke proyek anda susun. Pilihan ada di anda.
\nSemua gudang berkas pesan tersusun cara sama. Mereka adalah:
\nSemua jalur-jalur terdaftar dalam LOCALE_PATHS di berkas pengaturan anda adalah dicari untuk 1/LC_MESSAGES/django.(po|mo)
$APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)``
$PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)
Untuk membuat berkas pesan, anda menggunakan , anda menggunakan alat django-admin makemessages . Dan anda menggunakan django-admin compilemessages untuk menghasilkan berkas-berkas biner .mo yang digunakan oleh gettext.
Anda dapat juga menjalankan django-admin compilemessages --settings=path.to.settings 1 untuk membuat penyusun mengolah semua direktori dalam pengaturan LOCALE_PATHS anda.
Django membuat anggapan umum bahwa string asli dalam proyek terjemahan ditulis dalam Inggris. Anda dapat memilih bahasa lain, tetapi harus waspada dari batasan tertentu:
\ngettext only provides two plural forms for the original messages, so you\nwill also need to provide a translation for the base language to include all\nplural forms if the plural rules for the base language are different from\nEnglish.
When an English variant is activated and English strings are missing, the\nfallback language will not be the LANGUAGE_CODE of the project,\nbut the original strings. For example, an English user visiting a site with\nLANGUAGE_CODE set to Spanish and original strings written in\nRussian will see Russian text rather than Spanish.