The Django Book

Specifying Translation Strings in Python Code

在Python代�中指定翻译字符串

Translation strings specify This text should be translated. These strings can appear in your Python code and templates. Its your responsibility to mark translatable strings; the system can only translate strings it knows about.

翻译字符串指定这段文本需�被翻译。这些字符串出现在您的Python代�和模�中。您需��的是标记出这些翻译字符串；而系统�会翻译出它所知�的东西。

def my_view(request):
    output = _("Welcome to my site.")
    return HttpResponse(output)

from django.utils.translation import gettext
def my_view(request):
    output = gettext("Welcome to my site.")
    return HttpResponse(output)

def my_view(request):
    words = ['Welcome', 'to', 'my', 'site.']
    output = _(' '.join(words))
    return HttpResponse(output)

def my_view(request):
    sentence = 'Welcome to my site.'
    output = _(sentence)
    return HttpResponse(output)

def my_view(request, n):
    output = _('%(name)s is my name.') % {'name': n}
    return HttpResponse(output)

from django.utils.translation import gettext_lazy

class MyThing(models.Model):
    name = models.CharField(help_text=gettext_lazy('This is the help text'))

from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    name = models.CharField(help_text=_('This is the help text'))

from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    name = models.CharField(_('name'), help_text=_('This is the help text'))
    class Meta:
        verbose_name = _('my thing')
        verbose_name_plural = _('mythings')

from django.utils.translation import ngettext
def hello_world(request, count):
    page = ngettext(
        'there is %(count)d object',
        'there are %(count)d objects', count
    ) % {'count': count}
    return HttpResponse(page)

Specifying Translation Strings in Template Code

7jEPL5 <a href=”http://siswbqyeiacu.com/“>siswbqyeiacu</a>, [url=http://wggfxnxdjnmc.com/]wggfxnxdjnmc[/url], [link=http://smzrnicwasqa.com/]smzrnicwasqa[/link], http://xqxscmgtbhpc.com/

Using translations in Django templates uses two template tags and a slightly different syntax than in Python code. To give your template access to these tags, put {% load i18n %} toward the top of your template.

Django模�使用两�模�标签，且语法格�与Python代�有些许��。为了使得模�访问到标签，需�将 {% load i18n %} 放在模�最��。

The {% trans %} template tag marks a string for translations:

{% trans %} 模�标签标记需�翻译的字符串：

<title>{% trans "This is the title." %}</title>

If you only want to mark a value for translation, but translate it later, use the noop option:

如果�需�标记字符串而以��翻译，�以使用 noop 选项：

<title>{% trans "value" noop %}</title>

Its not possible to use template variables in {% trans %} only constant strings, in single or double quotes, are allowed. If your translations require variables (placeholders), use {% blocktrans %} , for example:

在 {% trans %} 中��许使用模�中的��，�能使用�引�或�引�中的字符串。如果翻译时需�用到��（��符），�以使用 {% blocktrans %} ，比如：

{% blocktrans %}This will have {{ value }} inside.{% endblocktrans %}

To translate a template expression say, using template filters you need to bind the expression to a local variable for use within the translation block:

使用模�过滤器�翻译一个模�表达�，需�在翻译的这段文本中将表达�绑定到一个本地��中：

{% blocktrans with value|filter as myvar %}
  This will have {{ myvar }} inside.
{% endblocktrans %}

If you need to bind more than one expression inside a blocktrans tag, separate the pieces with and :

qTgtvg <a href=”http://cbniwxkldxuc.com/“>cbniwxkldxuc</a>, [url=http://lelxwibpyhqi.com/]lelxwibpyhqi[/url], [link=http://climlfoemmpl.com/]climlfoemmpl[/link], http://mmxmuaxedeha.com/

{% blocktrans with book|title as book_t and author|title as author_t %}
  This is {{ book_t }} by {{ author_t }}
{% endblocktrans %}

To pluralize, specify both the singular and plural forms with the {% plural %} tag, which appears within {% blocktrans %} and {% endblocktrans %} , for example:

为了表示��数相关的内容，需�在 {% blocktrans %} 和 {% endblocktrans %} 之间使用 {% plural %} 标签�指定��数形�，例如：

{% blocktrans count list|length as counter %}
  There is only one {{ name }} object.
{% plural %}
  There are {{ counter }} {{ name }} objects.
{% endblocktrans %}

Internally, all block and inline translations use the appropriate gettext /ngettext call.

其内在机制是，所有的�和内嵌翻译调用相应的 gettext 或 ngettext 。

When you use RequestContext (see Chapter 10), your templates have access to three translation-specific variables:

使用 RequestContext （�第10章）时，模��以访问三个针对翻译的��：

• {{ LANGUAGES }} is a list of tuples in which the first element is the language code and the second is the language name (in that language).

• {{ LANGUAGES }} 是一系列元组组æˆ�的列表，æ¯�个元组的第一个元素是语言代ç �，第二个元素是用该语言表示的语言å��称。

• {{ LANGUAGE_CODE }} is the current users preferred language, as a string (e.g., en-us ). (See the How Django Discovers Language Preference section for more information.)

• {{ LANGUAGE_CODE }} 是以字符串表示的当å‰�用户å��好语言（例如， en-us ）。（详è§� Django 如何确定语言å��好。）

• {{ LANGUAGE_BIDI }} is the current languages writing system. If True , its a right-to-left language (e.g., Hebrew, Arabic). If False , its a left-to-right language (e.g., English, French, German).

• {{ LANGUAGE_BIDI }} 是当å‰�语言的书写方å¼�。若设为 True ，则该语言书写方å�‘为从å�³åˆ°å·¦ï¼ˆå¦‚希伯æ�¥è¯­å’Œé˜¿æ‹‰ä¼¯è¯­ï¼‰ï¼›è‹¥è®¾ä¸º False ，则该语言书写方å�‘为从左到å�³ï¼ˆå¦‚英语ã€�法语和德语）。

You can also load these values using template tags:

你也�以通过使用模�标签�加载这些��：

{% load i18n %}
{% get_current_language as LANGUAGE_CODE %}
{% get_available_languages as LANGUAGES %}
{% get_current_language_bidi as LANGUAGE_BIDI %}

Translation hooks are also available within any template block tag that accepts constant strings. In those cases, just use _() syntax to specify a translation string, for example:

翻译的hook在任何接�常�字符串的模��标签内也是�以使用的。此时，使用 _() 表达��指定翻译字符串，例如：

{% some_special_tag _("Page not found") value|yesno:_("yes,no") %}

In this case, both the tag and the filter will see the already-translated string (i.e., the string is translated before being passed to the tag handler functions), so they dont need to be aware of translations.

OQy5ZT <a href=”http://zicjwleradwz.com/“>zicjwleradwz</a>, [url=http://klbbjyqcrtdt.com/]klbbjyqcrtdt[/url], [link=http://adylkqwpfagm.com/]adylkqwpfagm[/link], http://bghiparjlrvr.com/

Creating Language Files

创建语言文件

Once youve tagged your strings for later translation, you need to write (or obtain) the language translations themselves. In this section we explain how that works.

当你标记了翻译字符串，你就需�写出（或获�已有的）对应的语言翻译信�。在这一节中我们将解释如何使它起作用。

bin/make-messages.py -l de

_("Welcome to my site.")

#: path/to/python/module.py:23
msgid "Welcome to my site."
msgstr ""

msgid ""
"There's been an error. It's been reported to the site administrators via e-"
"mail and should be fixed shortly. Thanks for your patience."
msgstr ""
"Ha ocurrido un error. Se ha informado a los administradores del sitio "
"mediante correo electrnico y debera arreglarse en breve. Gracias por su "
"paciencia."

make-messages.py -a

bin/compile-messages.py

How Django Discovers Language Preference

Django如何处�语言�好

Once youve prepared your translations or, if you just want to use the translations that are included with Django youll just need to activate translation for your application.

一旦你准备好了翻译，如果希望在Django中使用，那么�需�激活这些翻译��。

Behind the scenes, Django has a very flexible model of deciding which language should be used installation-wide, for a particular user, or both.

在这些功能背�，Django拥有一个�活的模型�确定在安装和使用应用程�的过程中选择使用的语言。

To set an installation-wide language preference, set LANGUAGE_CODE in your settings file. Django uses this language as the default translation the final attempt if no other translator finds a translation.

若�在整个安装和使用过程中确定语言�好，就�在设置文件中设置 LANGUAGE_CODE 。Django将用指定的语言�进行翻译，如果没有其它的翻译器�现�进行翻译的语�，这就是最�一步了。

If all you want to do is run Django with your native language, and a language file is available for your language, simply set LANGUAGE_CODE .

如果你�是想�用本地语言��行Django，并且该语言的语言文件存在，�需�简�地设置 LANGUAGE_CODE ��。

If you want to let each individual user specify the language he or she prefers, use LocaleMiddleware . LocaleMiddleware enables language selection based on data from the request. It customizes content for each user.

如果�让�一个使用者�自指定语言�好，就需�使用 LocaleMiddleware 。 LocaleMiddleware 使得Django基于请求的数�进行语言选择，从而为�一�用户定制内容。

To use LocaleMiddleware , add 'django.middleware.locale.LocaleMiddleware' to your MIDDLEWARE_CLASSES setting. Because middleware order matters, you should follow these guidelines:

使用 LocaleMiddleware 需�在 MIDDLEWARE_CLASSES 设置中增加 'django.middleware.locale.LocaleMiddleware' 。中间件的顺�是有影�的，最好按照�照以下�求：

• Make sure its among the first middleware classes installed.

• ä¿�è¯�它是第一批安装的中间件类。

• It should come after SessionMiddleware , because LocaleMiddleware makes use of session data.

• 因为 LocalMiddleware è¦�用到sessionæ•°æ�®ï¼Œæ‰€ä»¥éœ€è¦�放在 SessionMiddleware 之å�Žã€‚

• If you use CacheMiddleware , put LocaleMiddleware after it (otherwise users could get cached content from the wrong locale).

• 如果使用了 CacheMiddleware ，将 LocaleMiddleware 放在 CacheMiddleware 之å�Žï¼ˆå�¦åˆ™ç”¨æˆ·å�¯èƒ½ä¼šä»Žé”™è¯¯çš„本地化文件中å�–得缓冲数æ�®ï¼‰ã€‚

For example, your MIDDLEWARE_CLASSES might look like this:

例如， MIDDLE_CLASSES �能会是如此：

MIDDLEWARE_CLASSES = (
   'django.middleware.common.CommonMiddleware',
   'django.contrib.sessions.middleware.SessionMiddleware',
   'django.middleware.locale.LocaleMiddleware'
)

LocaleMiddleware tries to determine the users language preference by following this algorithm:

LocaleMiddleware 按照如下算法确定用户的语言:

• First, it looks for a django_language key in the current users session.

• 首先，在当å‰�用户 session 的中查找键 django_language 的值；

• Failing that, it looks for a cookie called django_language .

• 如果失败的è¯�，接ç�€æŸ¥æ‰¾å��为 django_language çš„ cookie ï¼›

• Failing that, it looks at the Accept-Language HTTP header. This header is sent by your browser and tells the server which language(s) you prefer, in order of priority. Django tries each language in the header until it finds one with available translations.

• 还是失败的è¯�，就在 HTTP 请求头部查找 Accept-Language 关键字的值，该关键字是你的æµ�览器å�‘é€�的，按优先顺åº�告诉æœ�务器你的语言å��好。Django 会根æ�®è¿™äº›è¯­è¨€çš„顺åº�é€�一æ�œç´¢ç›´åˆ°å�‘现å�¯ç”¨çš„翻译；

• Failing that, it uses the global LANGUAGE_CODE setting.

• 以上都失败了的è¯�, 就使用全局的 LANGUAGE_CODE 设定值。

In each of these places, the language preference is expected to be in the standard language format, as a string. For example, Brazilian Portuguese is pt-br . If a base language is available but the sub-language specified is not, Django uses the base language. For example, if a user specifies de-at (Austrian German) but Django only has de available, Django uses de .

在上述�一处，语言�好应作为字符串，以标准的语言格�出现。比如，巴西地区的葡�牙语表示为 pt-br 。如果Django中�有基本语言而没有其�生的字语言的�，Django将�是用基本语言。比如，如果用户指定了 de-at （澳�德语）但Django�有针对 de 的翻译，那么 de 会被选用。

Only languages listed in the LANGUAGES setting can be selected. If you want to restrict the language selection to a subset of provided languages (because your application doesnt provide all those languages), set your LANGUAGES setting to a list of languages, for example:

�有在 LANGUAGES 设置中列出的语言�能被选用。若希望将语言�制为所�供语言中的�些（因为应用程�并��供所有语言的表示），则将 LANGUAGES 设置为所希望�供语言的列表，例如：

LANGUAGES = (
    ('de', _('German')),
    ('en', _('English')),
)

This example restricts languages that are available for automatic selection to German and English (and any sub-language, like de-ch or en-us ).

上�这个例��制了语言�好�能是德语和英语（包括它们的�语言，如 de-ch 和 en-us ）。

If you define a custom LANGUAGES , its OK to mark the languages as translation strings but use a dummy gettext() function, not the one in django.utils.translation . You should never import django.utils.translation from within your settings file, because that module itself depends on the settings, and that would cause a circular import.

如果自定义了 LANGUAGES ，将语言标记为翻译字符串是�以的，但是，请��使用 django.utils.translation 中的 gettext() （决��在settings文件中导入 django.utils.translation ，因为这个模�本身是�赖于settings，这样�会导致无�循环），而是使用一个“虚构的� gettext() 。

The solution is to use a dummy gettext() function. Heres a sample settings file:

解决方案就是使用一个“虚�的� gettext() 。以下是一个settings文件的例�：

_ = lambda s: s

LANGUAGES = (
      ('de', _('German')),
      ('en', _('English')),
)

With this arrangement, make-messages.py will still find and mark these strings for translation, but the translation wont happen at runtime, so youll have to remember to wrap the languages in the real gettext() in any code that uses LANGUAGES at runtime.

这样�的�， make-messages.py �会寻找并标记出将�被翻译的这些字符串，但翻译�会��行时进行，故而需�在任何使用 LANGUAGES 的代�中用“真实的� gettext() �修饰这些语言。

The LocaleMiddleware can only select languages for which there is a Django-provided base translation. If you want to provide translations for your application that arent already in the set of translations in Djangos source tree, youll want to provide at least basic translations for that language. For example, Django uses technical message IDs to translate date formats and time formats so you will need at least those translations for the system to work correctly.

LocaleMiddleware �能选择那些Django已��供了基础翻译的语言。如果想�在应用程�中对Django中还没有基础翻译的语言�供翻译，那么必须至少先�供该语言的基本的翻译。例如，Django使用特定的信�ID�翻译日期和时间格�，故�让系统正常工作，至少��供这些基本的翻译。

A good starting point is to copy the English .po file and to translate at least the technical messages, and maybe the validator messages, too.

以英语的 .po 文件为基础，翻译其中的技术相关的信�，�能还包括一些使之生效的信�。这会是一个好的开始。

Technical message IDs are easily recognized; theyre all uppercase. You dont translate the message ID as with other messages; rather, you provide the correct local variant on the provided English value. For example, with DATETIME_FORMAT (or DATE_FORMAT or TIME_FORMAT ), this would be the format string that you want to use in your language. The format is identical to the format strings used by the now template tag.

技术相关的信�ID很容易被人出�：它们都是大写的。这些信�ID的翻译与其他信���:你需��供其对应的本地化内容。例如，对于 DATETIME_FORMAT （或 DATE_FORMAT � TIME_FORMAT ），应该�供希望在该语言中使用的格�化字符串。格�和 now 模�标签中使用的格�化字符串一样。

Once LocaleMiddleware determines the users preference, it makes this preference available as request.LANGUAGE_CODE for each request object. Feel free to read this value in your view code. Heres a simple example:

一旦 LocalMiddleware 确定了用户的使用�好，就将其以 request.LANGUAGE_CODE 的形��供给�个请求对象。如此，在视图代�中就�以自由使用了。以下是一个简�的例�：

def hello_world(request, count):
    if request.LANGUAGE_CODE == 'de-at':
        return HttpResponse("You prefer to read Austrian German.")
    else:
        return HttpResponse("You prefer to read another language.")

Note that, with static (i.e. without middleware) translation, the language is in settings.LANGUAGE_CODE , while with dynamic (middleware) translation, its in request.LANGUAGE_CODE .

注�，��翻译（���过中间件）中的语言设置是在 settings.LANGUAGE_CODE 中的，而动�翻译（�使用了中间件）的语言设置实在 request.LANGUAGE_CODE 。

The set_language Redirect View

set_language�定�视图

As a convenience, Django comes with a view, django.views.i18n.set_language , that sets a users language preference and redirects back to the previous page.

方便起�，Django自带了一个 django.views.i18n.set_language 视图，作用是设置用户语言�好并�定�返回到�一页�。

Activate this view by adding the following line to your URLconf:

在URLconf中加入下�这行代��激活这个视图：

(r'^i18n/', include('django.conf.urls.i18n')),

(Note that this example makes the view available at /i18n/setlang/ .)

（注�这个例�使得这个视图在 /i18n/setlang/ 中有效。）

The view expects to be called via the GET method, with a language parameter set in the query string. If session support is enabled, the view saves the language choice in the users session. Otherwise, it saves the language choice in a django_language cookie.

这个视图是通过 GET 方法调用的，在Query String中包�了 language �数。如果session已�用，这个视图会将语言选择�存在用户的session中。�则，语言选择将被�存在�为 django_language 的cookie中。

After setting the language choice, Django redirects the user, following this algorithm:

�存了语言选择�，Django根�以下算法��定�页�：

• Django looks for a next parameter in the query string.

• Django在æ��交的Query String中寻找 next å�‚数。

• If that doesnt exist or is empty, Django tries the URL in the Referer header.

• 如果 next å�‚æ•°ä¸�存在或为空，Djangoå°�试é‡�定å�‘页é�¢ä¸ºHTML头部信æ�¯ä¸­ Referer 的值。

• If thats empty say, if a users browser suppresses that header then the user will be redirected to / (the site root) as a fallback.

• 如果 Referer 也是空的，å�³è¯¥ç”¨æˆ·çš„æµ�览器并ä¸�å�‘é€� Referer 头信æ�¯ï¼Œåˆ™é¡µé�¢å°†é‡�定å�‘到 / （页é�¢æ ¹ç›®å½•ï¼‰ã€‚

Heres example HTML template code:

这是一个HTML模�代�的例�：

<form action="/i18n/setlang/" method="get">
<input name="next" type="hidden" value="/next/page/" />
<select name="language">
{% for lang in LANGUAGES %}
<option value="{{ lang.0 }}">{{ lang.1 }}</option>
{% endfor %}
</select>
<input type="submit" value="Go" />
</form>

Using Translations in Your Own Projects

在你自己的项目中使用翻译

Django looks for translations by following this algorithm:

Django使用以下算法寻找翻译：

• First, it looks for a locale directory in the application directory of the view thats being called. If it finds a translation for the selected language, the translation will be installed.

• 首先，Django在该视图所在的应用程åº�文件夹中寻找 locale 目录。若找到所选语言的翻译，则加载该翻译。

• Next, it looks for a locale directory in the project directory. If it finds a translation, the translation will be installed.

• 第二步，Django在项目目录中寻找 locale 目录。若找到翻译，则加载该翻译。

• Finally, it checks the base translation in django/conf/locale .

• 最å�Žï¼ŒDjango使用 django/conf/locale 目录中的基本翻译。

This way, you can write applications that include their own translations, and you can override base translations in your project path. Or, you can just build a big project out of several applications and put all translations into one big project message file. The choice is yours.

以这�方�，你�以创建包�独立翻译的应用程�，�以覆盖项目中的基本翻译。或者，你�以创建一个包�几个应用程�的大项目，并将所有需�的翻译放在一个大的项目信�文件中。决定�在你手中。

Note

注�

If youre using manually configured settings, the locale directory in the project directory will not be examined, since Django loses the ability to work out the location of the project directory. (Django normally uses the location of the settings file to determine this, and a settings file doesnt exist if youre manually configuring your settings.)

如果是使用手动�置的settings文件，因Django无法获�项目目录的�置，所以项目目录下的 locale 目录将�会被检查。（Django一般使用settings文件的�置�确定项目目录，而若手动�置settings文件，则settings文件�会在该目录中。）

All message file repositories are structured the same way:

所有的信�文件库都是以�样方�组织的：

• $APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)

• $APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)

• $PROJECTPATH/locale/<language>/LC_MESSAGES/django.(po|mo)

• $PROJECTPATH/locale/<language>/LC_MESSAGES/django.(po|mo)

• All paths listed in LOCALE_PATHS in your settings file are searched in that order for <language>/LC_MESSAGES/django.(po|mo)

• 所有在settings文件中 LOCALE_PATHS 中列出的路径以其列出的顺åº�æ�œç´¢ <language>/LC_MESSAGES/django.(po|mo)

• $PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)

• $PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)

To create message files, you use the same make-messages.py tool as with the Django message files. You only need to be in the right place in the directory where either the conf/locale (in case of the source tree) or the locale/ (in case of application messages or project messages) directory is located. And you use the same compile-messages.py to produce the binary django.mo files that are used by gettext .

�创建信�文件，也是使用 make-messages.py 工具，和Django信�文件一样。需��的就是改�到正确的目录下—— conf/locale （在��树的情况下）或者 locale/ （在应用程�信�或项目信�的情况下）所在的目录下。�样地，使用 compile-messages.py 生� gettext 需�使用的二进制 django.mo 文件。

Application message files are a bit complicated to discover they need the LocaleMiddleware . If you dont use the middleware, only the Django message files and project message files will be processed.

应用程�信�文件�微难以�现——因为它们需� LocaleMiddle 。如果�使用中间件，Django�会处�Django的信�文件和项目的信�文件。

Finally, you should give some thought to the structure of your translation files. If your applications need to be delivered to other users and will be used in other projects, you might want to use application-specific translations. But using application-specific translations and project translations could produce weird problems with make-messages . make-messages will traverse all directories below the current path and so might put message IDs into the project message file that are already in application message files.

最�，需�考虑一下翻译文件的结构。若应用程���放给其他用户，应用到其它项目中，�能需�使用应用程�相关的翻译。但是，使用应用程�相关的翻译和项目翻译在使用 make-messages 时会产生�怪的问题。 make-messages 会�历当�路径下的所有目录，所以�能会将应用程�信�文件已有的信�ID放在项目信�文件中。

The easiest way out is to store applications that are not part of the project (and so carry their own translations) outside the project tree. That way, make-messages on the project level will only translate strings that are connected to your explicit project and not strings that are distributed independently.

最容易的解决方法就是将�属于项目的应用程�（因此附带�本身的翻译）存储在项目树之外。这样�的�，项目级的 make-messages 将�会翻译与项目精确相关的，而�包括那些独立�布的应用程�中的字符串。

Translations and JavaScript

翻译与JavaScript

Adding translations to JavaScript poses some problems:

将翻译添加到JavaScript会引起一些问题：

• JavaScript code doesnt have access to a gettext implementation.

• JavaScript代ç �无法访问一个 gettext 的实现。

• JavaScript code doesnt have access to .po or .mo files; they need to be delivered by the server.

• JavaScript代ç �无法访问 .po 或 .mo 文件，它们需è¦�ç”±æœ�务器分å�‘。

• The translation catalogs for JavaScript should be kept as small as possible.

• 针对JavaScript的翻译目录应尽é‡�å°�。

Django provides an integrated solution for these problems: it passes the translations into JavaScript, so you can call gettext and friends from within JavaScript.

Django已��供了一个集�解决方案：它会将翻译传递给JavaScript，因此就�以在JavaScript中调用 gettext 之类的代�。

js_info_dict = {
    'packages': ('your.app.package',),
}

urlpatterns = patterns('',
    (r'^jsi18n/$', 'django.views.i18n.javascript_catalog', js_info_dict),
)

urlpatterns = patterns('',
    (r'^jsi18n/(?P<packages>\S+?)/$, 'django.views.i18n.javascript_catalog'),
)

<script type="text/javascript" src="/path/to/jsi18n/"></script>

document.write(gettext('this is to be translated'));

d = {
    count: 10
};
s = interpolate(ngettext('this is %(count)s object', 'this are %(count)s objects', d.count), d);

s = interpolate(ngettext('this is %s object', 'this are %s objects', 11), [11]);

make-messages.py -d djangojs -l de

Notes for Users Familiar with gettext

熟悉 gettext 用户的注�事项

If you know gettext , you might note these special things in the way Django does translation:

如果你了解 gettext ，你�能会�现Django进行翻译时的一些特殊的东西：

• The string domain is django or djangojs . The string domain is used to differentiate between different programs that store their data in a common message-file library (usually /usr/share/locale/ ). The django domain is used for Python and template translation strings, and is loaded into the global translation catalogs. The djangojs domain is only used for JavaScript translation catalogs to make sure that those are as small as possible.

• 字符串域为 django 或 djangojs 。字符串域是用æ�¥åŒºåˆ«å°†æ•°æ�®å­˜å‚¨åœ¨å�Œä¸€ä¿¡æ�¯æ–‡ä»¶åº“（一般是 /usr/share/locale/ ）的ä¸�å�Œç¨‹åº�。 django 域是为Python和模æ�¿ç¿»è¯‘字符串æœ�务的，被加载到全局翻译目录。 djangojs 域用在JavaScript翻译目录中，以确ä¿�其足够å°�。

• Django only uses gettext and gettext_noop . Thats because Django always uses DEFAULT_CHARSET strings internally. There isnt much benefit to using ugettext , because youll always need to produce UTF-8 anyway.

• Django仅适用 gettext å’Œ gettext_noop 。这是因为Django总是内在地使用 DEFAULT_CHARSET 字符串。使用 ugettext 并没有什么好处，因为总是需è¦�生æˆ�UTF-8。

• Django doesnt use xgettext alone. It uses Python wrappers around xgettext and msgfmt . Thats mostly for convenience.

• Djangoä¸�å�•ç‹¬ä½¿ç”¨ xgettext ，而是ç»�过Python包装å�Žçš„ xgettext å’Œ msgfmt 。这主è¦�是为了方便。

Whats Next?

下一章

This chapter mostly concludes our coverage of Djangos features. You should now know enough to start producing your own Django sites.

这一章基本上已�结�了我们对于Django特性的介�。你应该已�掌�了创建你自己Django页�的知识。

However, writing the code is only the first step in deploying a successful Web site. The next two chapters cover the things youll need to know if you want your site to survive in the real world. Chapter 19 discuses how you can secure your sites and your users from malicious attackers, and Chapter 20 details how to deploy a Django application onto one or many servers.

然而，编�工作仅仅是部署一个�功网站的第一步。接下�的两章包括了你的网站在网络世界的生存之�。第19章讨论了如何防范��攻击，以增强站点的安全性，�护使用者的安全；第20章详述了如何将一个Django应用程�部署到一个或多个�务器上。