{% if athlete_list %}
{% for athlete in athlete_list %}
{{ athlete.name }}
{% endfor %}
{% else %}
Sorry, no athletes in this list.
{% endif %}
```
### `if`
`{% if %}` タグは変数を評価し、その変数が "true" であるとき (すなわち変数が存在し、空ではなく、その値が False でないとき ) にブロックの内容を出力します:
```html+django
{% if athlete_list %}
Number of athletes: {{ athlete_list|length }}
{% elif athlete_in_locker_room_list %}
Athletes should be out of the locker room soon!
{% else %}
No athletes.
{% endif %}
```
上の例では、 `athlete_list` が空でなければ、アスリートの人数を `{{ athlete_list|length }}` 変数で表示します。
例にもあるように `if` タグはオプションで 1 個以上の `{% elif %}` 節、および 1 個の `{% else %}` 節をつけることができます。 `{% else %}` はそれまでの評価結果がすべて True でなかった場合に表示されるコンテンツを定義します。
#### 論理演算子
[`if`](#std-templatetag-if) タグは `and` `or` `not` を使って複数の変数を組み合わせてテストしたり、条件を逆にしたりすることができます:
```html+django
{% if athlete_list and coach_list %}
Both athletes and coaches are available.
{% endif %}
{% if not athlete_list %}
There are no athletes.
{% endif %}
{% if athlete_list or coach_list %}
There are some athletes or some coaches.
{% endif %}
{% if not athlete_list or coach_list %}
There are no athletes or there are some coaches.
{% endif %}
{% if athlete_list and not coach_list %}
There are some athletes and absolutely no coaches.
{% endif %}
```
`and` と `or` は同じタグの中で同時に使用できます。このとき優先順位は `and` が優先します:
```html+django
{% if athlete_list and coach_list or cheerleader_list %}
```
これは以下のように解釈されます:
```python
if (athlete_list and coach_list) or cheerleader_list
```
実際には [`if`](#std-templatetag-if) タグの中で丸括弧を使うことはできません。優先順位を示す必要がある場合には、[`if`](#std-templatetag-if) タグを入れ子にして表してください。
[`if`](#std-templatetag-if) tags may also use the operators `==`, `!=`, `<`, `>`,
`<=`, `>=`, `in`, `not in`, `is`, and `is not` which work as
follows:
##### `==` 演算子
等しい場合。例:
```html+django
{% if somevar == "x" %}
This appears if variable somevar equals the string "x"
{% endif %}
```
##### `!=` 演算子
等しくない場合。例:
```html+django
{% if somevar != "x" %}
This appears if variable somevar does not equal the string "x",
or if somevar is not found in the context
{% endif %}
```
##### `<` 演算子
より小さい場合。例:
```html+django
{% if somevar < 100 %}
This appears if variable somevar is less than 100.
{% endif %}
```
##### `>` 演算子
より大きい場合。例:
```html+django
{% if somevar > 0 %}
This appears if variable somevar is greater than 0.
{% endif %}
```
##### `<=` 演算子
より小さい、または等しい場合。例:
```html+django
{% if somevar <= 100 %}
This appears if variable somevar is less than 100 or equal to 100.
{% endif %}
```
##### `>=` 演算子
より大きい、または等しい場合。例:
```html+django
{% if somevar >= 1 %}
This appears if variable somevar is greater than 1 or equal to 1.
{% endif %}
```
##### `in` 演算子
コンテナに含まれている場合。これは与えられた値がコンテナの中に存在するかどうかをテストする演算子で、多くの Python コンテナに対して使用できます。以下は `x in y` がどのように解釈されるかを示した例です:
```html+django
{% if "bc" in "abcdef" %}
This appears since "bc" is a substring of "abcdef"
{% endif %}
{% if "hello" in greetings %}
If greetings is a list or set, one element of which is the string
"hello", this will appear.
{% endif %}
{% if user in users %}
If users is a QuerySet, this will appear if user is an
instance that belongs to the QuerySet.
{% endif %}
```
##### `not in` 演算子
コンテナに含まれていない場合。これは `in` 演算子の逆です。
##### `is` 演算子
Object identity. Tests if two values are the same object. Example:
```html+django
{% if somevar is True %}
This appears if and only if somevar is True.
{% endif %}
{% if somevar is None %}
This appears if somevar is None, or if somevar is not found in the context.
{% endif %}
```
##### `is not` operator
Negated object identity. Tests if two values are not the same object. This is
the negation of the `is` operator. Example:
```html+django
{% if somevar is not True %}
This appears if somevar is not True, or if somevar is not found in the
context.
{% endif %}
{% if somevar is not None %}
This appears if and only if somevar is not None.
{% endif %}
```
#### フィルター
[`if`](#std-templatetag-if) 内でフィルタを使うこともできます。例を示します:
```html+django
{% if messages|length >= 100 %}
You have lots of messages today!
{% endif %}
```
#### 複雑な表現
ここまでのすべてを組み合わせて複雑な式を作ることができます。このような式では、式を評価するときに演算子がどのようにグループ化されるか、すなわち優先順位の規則を理解することが重要です。演算子の優先順位は次のようになっています:
- `or`
- `and`
- `not`
- `in`
- `==`, `!=`, `<`, `>`, `<=`, `>=`
( この順序は Python とまったく同じです) 。 そこで、例えば次にあげる複雑な [`if`](#std-templatetag-if) タグの場合:
```html+django
{% if a == b or c == d and e %}
```
...次のように解釈されます:
```python
(a == b) or ((c == d) and e)
```
もしこれと違った優先順位が必要ならば、[`if`](#std-templatetag-if) タグを入れ子にして使う必要があります。優先順位の規則がはっきりしない場合には、こうした方がより明確な表現になることもあるでしょう。
比較演算子は Python や数学における記法のように、つないで書くことはできません。例えば次のような使い方はできません:
```html+django
{% if a > b > c %} (WRONG)
```
このように使うべきです:
```html+django
{% if a > b and b > c %}
```
### `ifequal` と `ifnotequal`
`{% ifequal a b %} ... {% endifequal %}` は、 `{% if a == b %} ... {% endif %}` の古い書き方です。同様に、 `{% ifnotequal a b %} ... {% endifnotequal %}` という書き方も `{% if a != b %} ... {% endif %}` に代わっています。 `ifequal` と `ifnotequal` タグは、将来のリリースで廃止される可能性があります。
### `ifchanged`
値が前回のループ実行時から変わっているかどうかを調べます。
`{% ifchanged %}` ブロックタグはループの内部で使います。このタグには 2 通りの使い方があります。
1. 今回の出力内容が、前回の状態に対して変化しているときだけ表示します。例えば、日付の一覧を表示する場合に、月が変わったときだけ月名を表示したければ以下のようにします:
```html+django
Archive for {{ year }}
{% for date in days %}
{% ifchanged %}
{{ date|date:"F" }}
{% endifchanged %}
{{ date|date:"j" }}
{% endfor %}
```
2. タグに 1 個以上の変数が与えられている場合、それぞれの変数について内容が変化したかどうかを調べます。例えば、以下の例では日付が変化したときには日付を表示し、日付と時刻が同時に変化したときのみ時刻も表示します:
```html+django
{% for date in days %}
{% ifchanged date.date %} {{ date.date }} {% endifchanged %}
{% ifchanged date.hour date.date %}
{{ date.hour }}
{% endifchanged %}
{% endfor %}
```
`ifchanged` タグは、オプションで `{% else %}` 節を使うこともできます。これは値に変化がないときに表示されます:
```html+django
{% for match in matches %}
{{ match }}
{% endfor %}
```
### `include`
テンプレートをロードし、現在のコンテキストを使って出力します。これはテンプレート内に他のテンプレートを取り込む（ “include” ）方法の一つです。
テンプレート名はハードコードされた (引用符で囲った) 文字列でもよく、引用符は一重引用符 （'...'）でも二重引用符（"..."）でもかまいません。
次の例では、 `"foo/bar.html"` という名前のテンプレートの内容を include します:
```html+django
{% include "foo/bar.html" %}
```
Normally the template name is relative to the template loader's root directory.
A string argument may also be a relative path starting with `./` or `../`
as described in the [`extends`](#std-templatetag-extends) tag.
次の例では、変数 `template_name` の値をテンプレート名として、そのテンプレートの内容を include します:
```html+django
{% include template_name %}
```
変数は、コンテキストを受け取る `render()` メソッドを持っていればオブジェクトでも構いません。これによって、コンテキスト内のコンパイル済みの `Template` を参照することができます。
include されたテンプレートは、include した側のコンテキストにおいて解釈されます。以下の例は `"Hello, John!"` を出力します:
- コンテキスト: 変数 `person` に `"John"` を、変数 `greeting` に `"Hello"` をセット。
- テンプレート:
```html+django
{% include "name_snippet.html" %}
```
- `name_snippet.html` テンプレート:
```html+django
{{ greeting }}, {{ person|default:"friend" }}!
```
キーワード引数を使って、テンプレートに追加のコンテキストを渡すことができます:
```html+django
{% include "name_snippet.html" with person="Jane" greeting="Hello" %}
```
あらかじめ準備された変数だけを使って (あるいは変数をまったく使わずに) 出力させたい場合は `only` オプションを使います。テンプレートを取り込むために、他の変数は利用できません:
```html+django
{% include "name_snippet.html" with greeting="Hi" only %}
```
> **Note**
>
> [`include`](#std-templatetag-include) タグの実行は『サブテンプレートを出力し、その結果である HTML を取り込む』と考えるべきで、『サブテンプレートを解析し、親テンプレートの一部分として、そこに組み込まれている』かのように考えるべきではありません。これは、取り込んだテンプレートの間では状態を共有できず、まったく独立した過程で出力されることを意味します。
>
> ブロックは取り込まれる *前に* 評価されます。ブロックを含んでいる他のテンプレートを取り込む場合、そのブロックは『 *すでに評価され、出力された結果* 』としてのブロックであり、例えばテンプレートを継承したときのような、オーバーライド可能なブロックではありません。
### `load`
カスタムのテンプレートタグセットを読み込みます。
例えば次のテンプレートは `somelibrary` 、そして `package` パッケージの\`\`otherlibrary\`\` に登録されたすべてのタグとフィルタを読み込みます。:
```html+django
{% load somelibrary package.otherlibrary %}
```
引数に `from` を使えば、ライブラリからフィルタやタグを個別に選んで読み込むことができます。以下の例では、 `foo`、`bar` という名前のテンプレートタグまたはフィルタを `somelibrary` から読み込みます:
```html+django
{% load foo bar from somelibrary %}
```
詳しくは [Custom tag and filter libraries](/ja/2.2/howto/custom-template-tags/) を参照してください。
### `lorem`
ランダムな"lorem ipsum" のラテン語テキストを表示させます。テンプレート内でサンプルデータを用意するのに便利です。
使い方は以下の通りです:
```html+django
{% lorem [count] [method] [random] %}
```
`{% lorem %}` タグは 0 から 3 個の引数をとります:
| Argument | 説明 |
| --- | --- |
| `count` | 生成する単語または段落の数を指定する、数値または変数 (デフォルトは 1 ) 。 |
| `method` | `w` のとき単語を、`p` のとき HTML の段落ブロック、`b` のときプレーンテキストの段落ブロックを生成します ( デフォルトは `b` )。 |
| `random` | `random` が与えられたとき、一般的な文章 ( "Lorem ipsum dolor sit amet..." ) を使わずにテキストを生成します。 |
例:
- `{% lorem %}` は、一般的な "lorem ipsum" を出力します。
- `{% lorem 3 p %}` は一般的な "lorem ipsum" と 2 個のランダムな文章を、それぞれ HTML の `
` タグで括って出力します。
- `{% lorem 2 w random %}` は 2 個のランダムなラテン単語を出力します。
### `now`
指定したフォーマット文字列にしたがって現在の日付や時刻を表示します。フォーマット文字列で使われる文字については、 [`date`](#std-templatefilter-date) フィルタの項で説明しています。
実装例:
```html+django
It is {% now "jS F Y H:i" %}
```
文字列の中でフォーマット文字を普通の文字として扱いたい場合は、バックスラッシュ文字（ `\` ）でエスケープします。次の例では、 "o" と "f" をエスケープしています。そうしなければ、これらはそれぞれ年と時刻を表示するためのフォーマット文字だと見なされるからです:
```html+django
It is the {% now "jS \o\f F" %}
```
この表示結果は "It is the 4th of September" となります。
> **Note**
>
> フォーマットはプリセット（ [`DATE_FORMAT`](/ja/2.2/ref/settings/#std-setting-DATE_FORMAT)、 [`DATETIME_FORMAT`](/ja/2.2/ref/settings/#std-setting-DATETIME_FORMAT)、 [`SHORT_DATE_FORMAT`](/ja/2.2/ref/settings/#std-setting-SHORT_DATE_FORMAT)、 [`SHORT_DATETIME_FORMAT`](/ja/2.2/ref/settings/#std-setting-SHORT_DATETIME_FORMAT) ）の中から 1 つを選ぶこともできます。 [表示形式のローカル化](/ja/2.2/topics/i18n/formatting/) が有効なときは、プリセットフォーマットの内容は現在設定されているロケールによって変わります。
>
> ```html+django
> It is {% now "SHORT_DATETIME_FORMAT" %}
> ```
出力を (文字列として) 変数に入れる場合には `{% now "Y" as current_year %}` の書式が使えます。これは [`blocktrans`](/ja/2.2/topics/i18n/translation/#std-templatetag-blocktrans) のようなテンプレートタグで `{% now %}` を使いたいときに役立ちます:
```html+django
{% now "Y" as current_year %}
{% blocktrans %}Copyright {{ current_year }}{% endblocktrans %}
```
### `regroup`
オブジェクトのリストから、同じ属性値を持つオブジェクトのグループを作ります。
This complex tag is best illustrated by way of an example: say that `cities`
is a list of cities represented by dictionaries containing `"name"`,
`"population"`, and `"country"` keys:
```python
cities = [
{'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},
{'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},
{'name': 'New York', 'population': '20,000,000', 'country': 'USA'},
{'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},
{'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},
]
```
...そして、あなたは次のように、国別に並べた一覧を表示させたいものとしましょう:
- India
- Mumbai: 19,000,000
- Calcutta: 15,000,000
- USA
- New York: 20,000,000
- Chicago: 7,000,000
- Japan
- Tokyo: 33,000,000
ここで `{% regroup %}` タグを使って都市のリストを国別にグループ化することができます。以下は、これを実現するためのテンプレートコードのスニペットです:
```html+django
{% regroup cities by country as country_list %}
{% for country in country_list %}
{{ country.grouper }}
{% for city in country.list %}
{{ city.name }}: {{ city.population }}
{% endfor %}
{% endfor %}
```
順に追ってみましょう。`{% regroup %}` タグは 3 つの引数を持ちます: グループ分けを行うリスト、グループ分けに使う属性の名前、そして結果とするリストの名前の 3 つです。ここでは `cities` リストを `country` 属性を使ってグループに分け、その結果を `country_list` と呼ぶことにしています。
`{% regroup %}` produces a list (in this case, `country_list`) of
**group objects**. Group objects are instances of
[`namedtuple()`](https://docs.python.org/3/library/collections.html#collections.namedtuple) with two fields:
- `grouper` -- グループ分けに使われた要素 ( ここでは "India" "Japan" といった文字列 )
- `list` -- このグループ内のすべての要素からなるリスト ( たとえば country='India' であるすべての都市のリスト)
Because `{% regroup %}` produces [`namedtuple()`](https://docs.python.org/3/library/collections.html#collections.namedtuple) objects,
you can also write the previous example as:
```html+django
{% regroup cities by country as country_list %}
{% for country, local_cities in country_list %}
{{ country }}
{% for city in local_cities %}
{{ city.name }}: {{ city.population }}
{% endfor %}
{% endfor %}
```
{% regroup %} は入力をソートしないことに注意してください! 上の例では、 リスト `cities` は、あらかじめ `country` の順でソート済みだという前提です。 `cities` が `country` の順に並べられて *いなかった* 場合、 regroup はそのまま何も考えずに 1 つの国に対してグループを 1 つ以上作ってしまうかもしれません。例えばリスト `cities` が、次のように ( リスト内で国ごとにまとまっていない状態に ) なっていたとしましょう:
```python
cities = [
{'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},
{'name': 'New York', 'population': '20,000,000', 'country': 'USA'},
{'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},
{'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},
{'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},
]
```
この `cities` を入力に使うと、先ほどの `{% regroup %}` テンプレートコードは次のような結果を出力するでしょう:
- India
- Mumbai: 19,000,000
- USA
- New York: 20,000,000
- India
- Calcutta: 15,000,000
- USA
- Chicago: 7,000,000
- Japan
- Tokyo: 33,000,000
このような落し穴を解決するには、ビューコード内であらかじめデータを表示したい順番に並べておくのが最も簡単でしょう。
データが辞書のリストである場合には、もう一つの解決策として、テンプレートの中で [`dictsort`](#std-templatefilter-dictsort) フィルタを使ってデータを並べ変えることができます:
```html+django
{% regroup cities|dictsort:"country" by country as country_list %}
```
#### その他の属性によるグループ化
テンプレートの有効な参照は、いずれも regroup タグでグループ化するための属性として扱うことができます。これにはメソッド、属性、辞書のキー、リスト項目が含まれます。例えば "country" というフィールドが外部キーで、その参照するクラスが "description" 属性を持つ場合、次のように使うことができます:
```html+django
{% regroup cities by country.description as country_list %}
```
また、 `country` が `choices` をともなうフィールドである場合、それは属性として使える [`get_FOO_display()`](/ja/2.2/ref/models/instances/#django.db.models.Model.get_FOO_display) メソッドを持っているので `choices` のキーではなく表示文字列でグループ化することができます。
```html+django
{% regroup cities by get_country_display as country_list %}
```
このとき `{{ country.grouper }}` は `choices` の辞書から、キーではなく値のフィールドを表示することでしょう。
### `resetcycle`
Resets a previous [cycle](#cycle) so that it restarts from its first item at its next
encounter. Without arguments, `{% resetcycle %}` will reset the last
`{% cycle %}` defined in the template.
使い方の例:
```html+django
{% for coach in coach_list %}
```
Notice how the first block ends with `class="odd"` and the new one starts
with `class="odd"`. Without the `{% resetcycle %}` tag, the second block
would start with `class="even"`.
You can also reset named cycle tags:
```html+django
{% for item in list %}
{{ item.data }}
{% ifchanged item.category %}
{{ item.category }}
{% if not forloop.first %}{% resetcycle tick %}{% endif %}
{% endifchanged %}
{% endfor %}
```
In this example, we have both the alternating odd/even rows and a "major" row
every fifth row. Only the five-row cycle is reset when a category changes.
### `spaceless`
ブロック内の HTML タグ間にある空白文字を除去します。タブ文字や改行も含みます。
使い方の例:
```html+django
{% spaceless %}
```
とり除かれるのは、タグとタグの間の空白だけです -- タグとテキストの間のスペースは除かれません。次の例では、 Hello の周りの空白をはぎとりません:
```html+django
{% spaceless %}
Hello
{% endspaceless %}
```
### `templatetag`
テンプレートタグの構文で使われる文字を、通常の文字として出力します。
Django のテンプレートには "エスケープ" の概念がないため、テンプレートタグで使われる文字を出力させるには {% templatetag %} タグを使わねばなりません。
どの要素を出力するかは、引数で指定します:
| Argument | 出力 |
| --- | --- |
| `openblock` | `{%` |
| `closeblock` | `%}` |
| `openvariable` | `{{` |
| `closevariable` | `}}` |
| `openbrace` | `{` |
| `closebrace` | `}` |
| `opencomment` | `{#` |
| `closecomment` | `#}` |
使用例:
```html+django
{% templatetag openblock %} url 'entry_list' {% templatetag closeblock %}
```
### `url`
ビューとオプションの引数を指定して、これとマッチする絶対パスへの参照 ( ドメイン部分を除いた URL ) を返します。結果のパスに特殊文字が含まれる場合、 [`iri_to_uri()`](/ja/2.2/ref/utils/#django.utils.encoding.iri_to_uri) を使ってエンコードされます。
これによって、テンプレート内での URL のハードコードで DRY 則を侵害することなく、リンクを出力することができます:
```html+django
{% url 'some-url-name' v1 v2 %}
```
The first argument is a [URL pattern name](/ja/2.2/topics/http/urls/#naming-url-patterns). It can
be a quoted literal or any other context variable. Additional arguments are
optional and should be space-separated values that will be used as arguments in
the URL. The example above shows passing positional arguments. Alternatively
you may use keyword syntax:
```html+django
{% url 'some-url-name' arg1=v1 arg2=v2 %}
```
1 つの呼び出しのなかで、固定引数とキーワード引数を混ぜることはできません。また URLconf で必要とされる引数はすべて指定しなければなりません。
例えば `app_views.client` という名前のビューがあって、クライアントの ID を引数に取るとしましょう ( `client()` は、 views ファイル `app_views.py` の中で定義されているメソッドです ) 。 URLconf は以下のようなものになるでしょう:
```python
path('client//', app_views.client, name='app-views-client')
```
このアプリケーションの URLconf が、プロジェクトの URLconf の中に次のような形で include されていたとします:
```python
path('clients/', include('project_name.app_name.urls'))
```
...このとき、テンプレート内でこのビューへのリンクを作るには、次のようにします:
```html+django
{% url 'app-views-client' client.id %}
```
テンプレートタグの出力は、文字列 `/clients/client/123/` となります。
Note that if the URL you're reversing doesn't exist, you'll get an
[`NoReverseMatch`](/ja/2.2/ref/exceptions/#django.urls.NoReverseMatch) exception raised, which will cause your
site to display an error page.
ページを表示させずに URL を取り出したい場合、少し違った呼び出し方が使えます:
```html+django
{% url 'some-url-name' arg arg2 as the_url %}
I'm linking to {{ the_url }}
```
\`\` ～ as 変数\`\` の構文で作られた変数は、 `{% url %}` タグのある `{% block %}` 内がスコープとなります。
次の例で、 `{% url ... as var %}` 構文はビューが見つからなくてもエラーを起こしません。実用としては、オプションのビューへリンクする場合に使えます:
```html+django
{% url 'some-url-name' as the_url %}
{% if the_url %}
Link to optional stuff
{% endif %}
```
名前空間化された URL を取り出したい場合は、完全修飾名で指定してください。
```html+django
{% url 'myapp:view-name' %}
```
これは通常の [namespaced URL resolution strategy](/ja/2.2/topics/http/urls/#topics-http-reversing-url-namespaces) に従います。ここには現在のアプリケーションに関してコンテキストから得られる様々なヒントについて書かれています。
> **Warning**
>
> Don't forget to put quotes around the URL pattern `name`, otherwise the
> value will be interpreted as a context variable!
### `verbatim`
このブロックタグ内では、テンプレートエンジンによる解釈を行いません。
これは JavaScript テンプレート の文法が Django と衝突してしまう時によく使われます。例えば:
```html+django
{% verbatim %}
{{if dying}}Still alive.{{/if}}
{% endverbatim %}
```
verbatim ブロックの中で "`{% endverbatim %}`" を使うには、開始・終了タグが特定できるように名前をつけます:
```html+django
{% verbatim myblock %}
Avoid template rendering via the {% verbatim %}{% endverbatim %} block.
{% endverbatim myblock %}
```
### `widthratio`
バーチャートなどを生成する場合のために、指定した値と最大値との比を計算し、 定数に掛けた値を返します。
例:
```html+django
```
ここで this\_value = 175 、 max\_value = 200 であるとき、画像の幅は 88 ピクセルになります (175 / 200 = .875、 .875 \* 100 = 87.5 から四捨五入して 88 )。
`widthratio` の結果を変数に入れてキャプチャーしたい場合があります。例えば [`blocktrans`](/ja/2.2/topics/i18n/translation/#std-templatetag-blocktrans) で使う場合、次のようにできます:
```html+django
{% widthratio this_value max_value max_width as width %}
{% blocktrans %}The width is: {{ width }}{% endblocktrans %}
```
### `with`
複雑な表現の変数の値をキャッシュし、簡単な名前で参照できるようにします。呼出しコストの高いメソッド (例えばデータベースを操作するようなメソッド) に何度もアクセスする際に便利です。
例:
```html+django
{% with total=business.employees.count %}
{{ total }} employee{{ total|pluralize }}
{% endwith %}
```
値を組み込んだ変数 (上の例でいえば `total` ) は `{% with %}` と `{% endwith %}` タグの間でだけ有効です。
コンテキスト変数は、複数割り当てることができます:
```html+django
{% with alpha=1 beta=2 %}
...
{% endwith %}
```
> **Note**
>
> 従来の冗長な書式もサポートされています: `{% with business.employees.count as total %}`
## 組み込みフィルタリファレンス
### `add`
入力値に対して引数の値を加算します。
例:
```html+django
{{ value|add:"2" }}
```
value が 4 なら、出力は 6 になるでしょう。
このフィルタは、まず両方の値を強制的に整数とみなして加算しようとします。失敗した場合は、とにかく値を足し合わせることを試みます。これはいくつかのデータ型 (文字列、リストなど) では動作しますが、それ以外では失敗します。失敗した場合、結果は空の文字列になります。
例として、次のようなフィルタがあるとしましょう:
```html+django
{{ first|add:second }}
```
`first` が `[1, 2, 3]` 、 `second` が `[4, 5, 6]` であった場合、出力は `[1, 2, 3, 4, 5, 6]` になります。
> **Warning**
>
> 整数に変換可能な文字列は、整数として「**加算**」されます。上の例のように「**結合**」されません。
### `addslashes`
引用符の前にスラッシュを追加します。CSV などの文字列をエスケープする際に便利です。
例:
```html+django
{{ value|addslashes }}
```
`value` の値が `"I'm using Django"` のとき、出力は `"I\'m using Django"` となります。
### `capfirst`
入力値の先頭の文字を大文字に変換します。最初の文字がアルファベットでなければ効果はありません。
例:
```html+django
{{ value|capfirst }}
```
If `value` is `"django"`, the output will be `"Django"`.
### `center`
入力値を引数で指定された幅のフィールド内に中央寄せします。
例:
```html+django
"{{ value|center:"15" }}"
```
`value` の値が `"django"` のとき、出力は `" Django "` となります。
### `cut`
入力値の中から、引数に指定した値を全て取り除きます。
例:
```html+django
{{ value|cut:" " }}
```
`value` の値が `"String with spaces"` のとき、出力は `"Stringwithspaces"` となります。
### `date`
引数に指定した書式で日付をフォーマットします。
いくつかの違いはありますが、フォーマットには PHP の `date()` 関数 ( ) に似た書式を使います。
> **Note**
>
> これらのフォーマット文字は、テンプレート以外では使えません。デザイナーが PHP のテンプレートから容易に変換できるように互換性を持たせています。
利用可能なフォーマット文字:
| フォーマット文字 | 説明 | 出力の例 |
| --- | --- | --- |
| **Day** | | |
| `d` | 日。 2 桁のゼロ詰め表示です。 | `'01'` ～ `'31'` |
| `j` | 日。ゼロ埋め表示なし。 | `'1'` ～ `'31'` |
| `D` | 曜日。 アルファベット 3 文字のテキスト形式です。 | `'Fri'` |
| `l` | 曜日。長いテキスト形式です。 | `'Friday'` |
| `S` | 日を表わす数字につける、英語特有の接尾辞。アルファベット 2 文字です。 | `'st'`, `'nd'`, `'rd'` or `'th'` |
| `w` | 曜日（数字 1 桁）。 | `'0'` (日曜) ～ `'6'` (土曜) |
| `z` | 日（１年間における） | `1` to `366` |
| **Week** | | |
| `W` | ISO-8601 による年間の週番号。 週は月曜日から始まります。 | `1`, `53` |
| **Month** | | |
| `m` | 月。数字 2 桁で、ゼロ埋め表示します。 | `'01'` ～ `'12'` |
| `n` | 月。ゼロ埋め表示しません。 | `'1'` ～ `'12'` |
| `M` | 月。アルファベット 3 文字のテキスト形式です。 | `'Jan'` |
| `b` | 月。アルファベット（小文字） 3 文字のテキスト形式です。 | `'jan'` |
| `E` | 月。ロケールが定義する代替表現が使われ、通常は長いテキスト形式になります。 | `'listopada'` ( ロケールがポーランド語の場合。ポーランド語 'Listopad（ 11 月）'の、時制における変化形 ) |
| `F` | 月。長いテキスト形式で表したものです。 | `'January'` |
| `N` | AP スタイルブックによる月の省略表記。独自の拡張です。 | `'Jan.'`, `'Feb.'`, `'March'`, `'May'` |
| `t` | その月の日数。 | `28` ～ `31` |
| **Year** | | |
| `y` | 年（ 2 桁）。 | `'99'` |
| `Y` | 年（ 4 桁）。 | `'1999'` |
| `L` | うるう年かどうかを表すブール値です。 | `True` または `False` |
| `o` | ISO-8601 の週番号付き記法による年。うるう週を用いた ISO-8601 週番号 (W) に対応します。一般的な年のフォーマットは Y を参照してください。 | `'1999'` |
| **Time** | | |
| `g` | 時（ 12 時間表記）。ゼロ埋め表示なし。 | `'1'` ～ `'12'` |
| `G` | 時（ 24 時間表記）。ゼロ埋め表示なし。 | `'0'` ～ `'23'` |
| `h` | 時（ 12 時間表記）。 | `'01'` ～ `'12'` |
| `H` | 時（ 24 時間表記）。 | `'00'` ～ `'23'` |
| `i` | 分。 | `'00'` ～ `'59'` |
| `s` | 秒。数字 2 桁で、ゼロ埋め表示です。 | `'00'` ～ `'59'` |
| `u` | マイクロ秒。 | `000000` ～ `999999` |
| `a` | `'a.m.'` または `'p.m.'` ( 注： PHP における出力と少し異なり、 AP スタイルブックに従ってピリオドをつけます ) | `'a.m.'` |
| `A` | `'AM'` または `'PM'` | `'AM'` |
| `f` | 時と分（12 時間表記）。ただしゼロ分であるときは時間だけを表示します。これは独自の拡張です。 | `'1'` ～ `'12'` |
| `P` | 時刻。12 時間表記による 時間:分 に続けて ‘a.m.’ または ’p.m.’ を表示します。ゼロ分である場合には分の表示が省略され、必要に応じて ‘midnight’ または ‘noon’ の表示になります。 独自の拡張です。 | `'1 a.m.'`, `'1:30 p.m.'`, `'midnight'`, `'noon'`, `'12:30 p.m.'` |
| **Timezone** | | |
| `e` | タイムゾーン名。どのフォーマットでも使えますが、 datetime によっては空の文字列を返す場合もあります。 | `''`, `'GMT'`, `'-500'`, `'US/Eastern'` など |
| `I` | 夏時間（DST）が有効か、そうでないかを表します。 | `'1'` または `'0'` |
| `O` | グリニッジ標準時からの時差。 | `'+0200'` |
| `T` | 計算機のタイムゾーン設定。 | `'EST'`, `'MDT'` |
| `Z` | タイムゾーンオフセットを秒であらわしたもの。UTC よりも西側のタイムゾーン値は全て負の値になり、東側の値は常に正になります。 | `-43200` ～ `43200` |
| **Date/Time** | | |
| `c` | ISO 8601 フォーマット。 ( 注： これは他の "Z"、"O"、"r" といったフォーマット文字とは異なり、 入力値がタイムゾーン情報を含まない（"naive"な） datetime であっても、タイムゾーンによる時差を加算しません ( [`datetime.tzinfo`](https://docs.python.org/3/library/datetime.html#datetime.tzinfo) を参照 )。 | `2008-01-02T10:30:00.000123+02:00` 、または datetime が naive である場合 `2008-01-02T10:30:00.000123` |
| `r` | [**RFC 5322**](https://datatracker.ietf.org/doc/html/rfc5322.html#section-3.3) formatted date. | `'Thu, 21 Dec 2000 16:01:07 +0200'` |
| `U` | Unix エポック時 ( UTC 協定世界時 1970年1月1日 00:00:00 ) からの秒数。 | |
例:
```html+django
{{ value|date:"D d M Y" }}
```
上の例で、値が [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime) オブジェクトである場合 ( 例えば `datetime.datetime.now()` の結果など ) 、出力は `'Wed 09 Jan 2008'` となります。
フォーマットには、プリセット（ [`DATE_FORMAT`](/ja/2.2/ref/settings/#std-setting-DATE_FORMAT), [`DATETIME_FORMAT`](/ja/2.2/ref/settings/#std-setting-DATETIME_FORMAT), [`SHORT_DATE_FORMAT`](/ja/2.2/ref/settings/#std-setting-SHORT_DATE_FORMAT) or [`SHORT_DATETIME_FORMAT`](/ja/2.2/ref/settings/#std-setting-SHORT_DATETIME_FORMAT) ）のうちの１つ、または上記の表で示したフォーマット指定文字を使ったカスタムフォーマットが使えます。プリセットのフォーマットは、現在のロケールに応じて表示が変化することに注意してください。
[`USE_L10N`](/ja/2.2/ref/settings/#std-setting-USE_L10N) が `True` であるとして、例えば [`LANGUAGE_CODE`](/ja/2.2/ref/settings/#std-setting-LANGUAGE_CODE) が `"es"` （スペイン語）である場合:
```html+django
{{ value|date:"SHORT_DATE_FORMAT" }}
```
上記の出力は、文字列 `"09/01/2008"` となります ( `es` ロケールの `"SHORT_DATE_FORMAT"` フォーマットは、 Django の初期設定では `"d/m/Y"` です)。
When used without a format string, the `DATE_FORMAT` format specifier is
used. Assuming the same settings as the previous example:
```html+django
{{ value|date }}
```
outputs `9 de Enero de 2008` (the `DATE_FORMAT` format specifier for the
`es` locale is `r'j \d\e F \d\e Y'`). Both "d" and "e" are
backslash-escaped, because otherwise each is a format string that displays the
day and the timezone name, respectively.
`date` を [`time`](#std-templatefilter-time) フィルタに繋ぐことで、`datetime` の表現をすべて表示させることができます。例えば次のようにします:
```html+django
{{ value|date:"D d M Y" }} {{ value|time:"H:i" }}
```
### `default`
入力の評価値が `False` の場合、引数に指定したデフォルト値を使います。そうでなければ、入力値を使います。
例:
```html+django
{{ value|default:"nothing" }}
```
`value` が `""` ( 空の文字列 ) のとき、出力は nothing\`\`になります。
### `default_if_none`
入力値が `None` であるとき ( `None` であるときのみ ) 、引数に指定したデフォルト値を使いま す。そうでなければ、入力値を使います。
空の文字列が入力された場合は、デフォルト値を *使わない* ことに注意してください。空文字列をフォールバックしたければ [`default`](#std-templatefilter-default) フィルタを使ってください。
例:
```html+django
{{ value|default_if_none:"nothing" }}
```
If `value` is `None`, the output will be `nothing`.
### `dictsort`
辞書のリストを入力として、引数に指定したキーでリストをソートして返します。
例:
```html+django
{{ value|dictsort:"name" }}
```
`value` が以下の内容であるとします:
```python
[
{'name': 'zed', 'age': 19},
{'name': 'amy', 'age': 22},
{'name': 'joe', 'age': 31},
]
```
このとき出力は以下のようになるでしょう:
```python
[
{'name': 'amy', 'age': 22},
{'name': 'joe', 'age': 31},
{'name': 'zed', 'age': 19},
]
```
より複雑なリストに対しても、以下のように処理できます:
```html+django
{% for book in books|dictsort:"author.age" %}
* {{ book.title }} ({{ book.author.name }})
{% endfor %}
```
ここで `books` が以下の内容だとします:
```python
[
{'title': '1984', 'author': {'name': 'George', 'age': 45}},
{'title': 'Timequake', 'author': {'name': 'Kurt', 'age': 75}},
{'title': 'Alice', 'author': {'name': 'Lewis', 'age': 33}},
]
```
すると出力は以下のようになります:
```html+django
* Alice (Lewis)
* 1984 (George)
* Timequake (Kurt)
```
`dictsort` can also order a list of lists (or any other object implementing
`__getitem__()`) by elements at specified index. For example:
```html+django
{{ value|dictsort:0 }}
```
`value` が以下の内容であるとします:
```python
[
('a', '42'),
('c', 'string'),
('b', 'foo'),
]
```
このとき出力は以下のようになるでしょう:
```python
[
('a', '42'),
('b', 'foo'),
('c', 'string'),
]
```
You must pass the index as an integer rather than a string. The following
produce empty output:
```html+django
{{ values|dictsort:"0" }}
```
Ordering by elements at specified index is not supported on dictionaries.
> **Changed in Django 2.2.26**
>
> In older versions, ordering elements at specified index was supported on
> dictionaries.
### `dictsortreversed`
辞書のリストを入力に取り、引数に指定したキーでリストを逆順にソートして返します。これは上のフィルタと全く同じ処理をしますが、返す値は逆順です。
### `divisibleby`
値が引数の値で割り切れる場合に `True` を返します。
例:
```html+django
{{ value|divisibleby:"3" }}
```
`value` が `21` であるとき、出力は `True` です。
### `escape`
入力文字中にある HTML の特殊文字をエスケープします。具体的には、以下のような置換を行います:
- `<` を `<` に変換
- `>` を `>` に変換
- `'` ( シングルクォート ) を `'` に変換
- `"` ( ダブルクォート ) を `"` に変換
- `&` を `&` に変換
`escape` を変数に適用するとき、変数にはすでに自動エスケープが適用されているかもしれませんが、エスケープが二重に実行されることはありません。したがって自動エスケープ環境であっても、この機能は安全に使用できます。複数回のエスケープが適用されるようにしたい場合は [`force_escape`](#std-templatefilter-force_escape) フィルターを使用してください。
以下は [`autoescape`](#std-templatetag-autoescape) がオフであるときに、フィールドに `escape` を適用する例です:
```html+django
{% autoescape off %}
{{ title|escape }}
{% endautoescape %}
```
### `escapejs`
Escapes characters for use in JavaScript strings. This does *not* make the
string safe for use in HTML or JavaScript template literals, but does protect
you from syntax errors when using templates to generate JavaScript/JSON.
例:
```html+django
{{ value|escapejs }}
```
`value` の値が `"testing\r\njavascript \'string" escaping"` であるとき、出力は `"testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E"` となります。
### `filesizeformat`
入力値を、人間が読みやすいファイルサイズ表現 ('13 KB', '4.1 MB', '102 bytes' など) に変換します。
例:
```html+django
{{ value|filesizeformat }}
```
`value` が 123456789 のとき、出力は `117.7 MB` になります。
> **ファイルサイズと国際単位系（SI）**
>
> `filesizeformat` は、厳密には国際単位系（SI）に準拠していません。国際単位系ではバイトサイズを 1024 の累乗で計算する場合 (上の例がそうですが) 、 KiB、MiB、GiB などの単位を使うよう推奨しています。しかし Django ではより一般的な表記に対応して、従来の単位名（ KB、 MB、GB など）を使用しています。
### `first`
リスト中の最初の要素を返します。
例:
```html+django
{{ value|first }}
```
`value` がリスト `['a', 'b', 'c']` であるとき、出力は 'a'になります。
### `floatformat`
引数なしで使った場合、浮動小数点数を小数点以下１桁に丸めます。ただし小数部分がない時には整数部分だけを表示します。例を示します:
| `value` | テンプレート | 出力 |
| --- | --- | --- |
| `34.23234` | `{{ value\|floatformat }}` | `34.2` |
| `34.00000` | `{{ value\|floatformat }}` | `34` |
| `34.26000` | `{{ value\|floatformat }}` | `34.3` |
引数に１以上の整数を指定した場合、 `floatformat` は小数部分を指定された桁数で丸めます。以下に例を示します:
| `value` | テンプレート | 出力 |
| --- | --- | --- |
| `34.23234` | `{{ value\|floatformat:3 }}` | `34.232` |
| `34.00000` | `{{ value\|floatformat:3 }}` | `34.000` |
| `34.26000` | `{{ value\|floatformat:3 }}` | `34.260` |
特に便利な使い方として、引数に 0 (ゼロ) を指定した場合、入力値を一番近い整数に丸めます。
| `value` | テンプレート | 出力 |
| --- | --- | --- |
| `34.23234` | `{{ value\|floatformat:"0" }}` | `34` |
| `34.00000` | `{{ value\|floatformat:"0" }}` | `34` |
| `39.56000` | `{{ value\|floatformat:"0" }}` | `40` |
引数に負の数を指定した場合、小数部分を指定された桁数（指定された数の絶対値）で丸めます。ただし小数部分がない時には整数部分だけを表示します。例を示します:
| `value` | テンプレート | 出力 |
| --- | --- | --- |
| `34.23234` | `{{ value\|floatformat:"-3" }}` | `34.232` |
| `34.00000` | `{{ value\|floatformat:"-3" }}` | `34` |
| `34.26000` | `{{ value\|floatformat:"-3" }}` | `34.260` |
`floatformat` を引数なしで使用した場合の動作は、引数に `-1` を指定した場合と同じです。
### `force_escape`
文字列に HTML エスケープを適用します。 ( 詳しくは [`escape`](#std-templatefilter-escape) フィルタを参照してください )。フィルタは *即座に* 適用され、新たなエスケープ済みの文字列を返します。このタグが有用となるケースは稀で、複数回のエスケープが必要な場合や、エスケープされた結果に対して他のフィルタを適用したい場合に使います。通常は [`escape`](#std-templatefilter-escape) フィルタを使うことになるでしょう。
例えば [`linebreaks`](#std-templatefilter-linebreaks) フィルタから生成された HTML 要素 `
` を捕らえたい場合、次のようになります:
```html+django
{% autoescape off %}
{{ body|linebreaks|force_escape }}
{% endautoescape %}
```
### `get_digit`
入力値が整数であるとき、引数で指定された桁にある数字を返します。例えば引数が 1 のとき右端の桁、 2 のとき右から 2 桁目が指定されます。入力が整数でない場合には、入力値をそのまま返します。
例:
```html+django
{{ value|get_digit:"2" }}
```
`value` が `123456789` のとき、出力は `8` です。
### `iriencode`
IRI (国際化リソース識別子 Internationalized Resource Identifier) を URL に適した文字列に変換します。これは非 ASCII 文字列を URL に埋め込む場合に必要なフィルタです。
[`urlencode`](#std-templatefilter-urlencode) フィルタを通した後の文字列を、このフィルタに通しても問題はありません。
例:
```html+django
{{ value|iriencode }}
```
`value` の値が `"?test=1&me=2"` のとき、出力は `"?test=1&me=2"` になります。
### `join`
Python の `str.join(list)` と同じく、リストを文字列でつなぎます。
例:
```html+django
{{ value|join:" // " }}
```
`value` の値がリスト `['a', 'b', 'c']` であるとき、出力は文字列 `"a // b // c"` となります。
### `json_script`
> **New in Django 2.1**
Safely outputs a Python object as JSON, wrapped in a `
```
The resulting data can be accessed in JavaScript like this:
```javascript
var value = JSON.parse(document.getElementById('hello-data').textContent);
```
XSS attacks are mitigated by escaping the characters "\<", "\>" and "&". For
example if `value` is `{'hello': 'world&'}`, the output is:
```html
```
This is compatible with a strict Content Security Policy that prohibits in-page
script execution. It also maintains a clean separation between passive data and
executable code.
### `last`
リストの末尾の要素を返します。
例:
```html+django
{{ value|last }}
```
`value` の値がリスト `['a', 'b', 'c', 'd']` のとき、出力は文字列 `"d"` です。
### `length`
入力値の長さを返します。これは、文字列とリストの両方で動作します。
例:
```html+django
{{ value|length }}
```
`value` が `['a', 'b', 'c', 'd']` 、 `"abcd"` であるとき、それぞれ出力は `4` になります。
The filter returns `0` for an undefined variable.
### `length_is`
入力値の長さと引数が等しければ `True` を返し、そうでなければ `False` を返します。
例:
```html+django
{{ value|length_is:"4" }}
```
`value` が `['a', 'b', 'c', 'd']` あるいは `"abcd"` であるとき、それぞれ出力は `True` です。
### `linebreaks`
Replaces line breaks in plain text with appropriate HTML; a single
newline becomes an HTML line break (` `) and a new line
followed by a blank line becomes a paragraph break (`
`).
例:
```html+django
{{ value|linebreaks }}
```
If `value` is `Joel\nis a slug`, the output will be `
Joel is a
slug
`.
### `linebreaksbr`
Converts all newlines in a piece of plain text to HTML line breaks
(` `).
例:
```html+django
{{ value|linebreaksbr }}
```
If `value` is `Joel\nis a slug`, the output will be `Joel is a
slug`.
### `linenumbers`
テキストを行番号付きで表示します。
例:
```html+django
{{ value|linenumbers }}
```
`value` が次の内容であるとき:
```html+django
one
two
three
```
その出力は次のようになります:
```html+django
1. one
2. two
3. three
```
### `ljust`
入力値を指定した幅のフィールド内で左詰めします。
**引数:** フィールドの幅
例:
```html+django
"{{ value|ljust:"10" }}"
```
`value` が `Django` であるとき、出力は `"Django "` となります。
### `lower`
文字列を全て小文字に変換します。
例:
```html+django
{{ value|lower }}
```
`value` が `Totally LOVING this Album!` であるとき、出力は `totally loving this album!` となります。
### `make_list`
Returns the value turned into a list. For a string, it's a list of characters.
For an integer, the argument is cast to a string before creating a list.
例:
```html+django
{{ value|make_list }}
```
`value` の値が文字列 `"Joel"` であるとき、出力はリスト `['J', 'o', 'e', 'l']` です。 `value` が `123` のとき、出力はリスト `['1', '2', '3']` となります。
### `phone2numeric`
電話番号 (文字を含む場合もあります) を数値だけの番号に変換します。
入力値は正しい電話番号でなくてもかまいません。このフィルタはどんな文字列でも変換します。
例:
```html+django
{{ value|phone2numeric }}
```
`value` が `800-COLLECT` のとき、出力は `800-2655328` となります。
### `pluralize`
Returns a plural suffix if the value is not `1`, `'1'`, or an object of
length 1. By default, this suffix is `'s'`.
実装例:
```html+django
You have {{ num_messages }} message{{ num_messages|pluralize }}.
```
`num_messages` が `1` のとき、出力は `You have 1 message.` です。 `num_messages` が `2` のとき、出力は `You have 2 messages.` となります。
`'s'` 以外の接尾辞が必要な場合は、代わりの接尾辞をフィルタの引数で指定できます。
実装例:
```html+django
You have {{ num_walruses }} walrus{{ num_walruses|pluralize:"es" }}.
```
単純な接尾辞では複数形にできない単語の場合、単数形と複数形の接尾辞の両方をコンマで区切って指定できます。
実装例:
```html+django
You have {{ num_cherries }} cherr{{ num_cherries|pluralize:"y,ies" }}.
```
> **Note**
>
> 飜訳された文字列を複数形に変換するときは [`blocktrans`](/ja/2.2/topics/i18n/translation/#std-templatetag-blocktrans) を使ってください。
### `pprint`
[`pprint.pprint()`](https://docs.python.org/3/library/pprint.html#pprint.pprint) のラッパーです -– 実のところ、これはデバッグ用です。
### `random`
与えられたリストからランダムな要素を返します。
例:
```html+django
{{ value|random }}
```
`value` の値がリスト `['a', 'b', 'c', 'd']` であるとき、出力は `"b"` かもしれません。
### `rjust`
入力値を指定した幅のフィールド内で右詰めします。
**引数:** フィールドの幅
例:
```html+django
"{{ value|rjust:"10" }}"
```
`value` が `Django` であるとき、出力は `" Django"` となります。
### `safe`
文字列に対して、さらなる HTML エスケープが必要でないことをマークするのに使います。 autoescaping がオフの場合、このフィルタは何もしません。
> **Note**
>
> フィルタを連鎖させる場合、 `safe` の後に適用されるフィルタはその内容を再び安全でない状態にしてしまうことが可能です。例えば以下のコードは、変数をそのまま、エスケープされない状態で出力します:
>
> ```html+django
> {{ var|safe|escape }}
> ```
### `safeseq`
シーケンスのそれぞれの要素に対して [`safe`](#std-templatefilter-safe) フィルタを適用します。これは例えば [`join`](#std-templatefilter-join) のような、シーケンスを処理する他のフィルタと組み合わせて使うのが便利です。例をあげます:
```html+django
{{ some_list|safeseq|join:", " }}
```
この場合、直接 [`safe`](#std-templatefilter-safe) フィルタを使用すると正しく動作しないかもしれません。シーケンスの個々の要素に対して作用するのではなく、まず変数を文字列に変換して処理するからです。
### `slice`
リストに対するスライスを返します。
Uses the same syntax as Python's list slicing. See
for an introduction.
実装例:
```html+django
{{ some_list|slice:":2" }}
```
`some_list` が `['a', 'b', 'c']` ならば、出力は `['a', 'b']` となります。
### `slugify`
ASCIIに変換します。スペースをハイフンに変換します。英数字以外の文字、アンダースコア、ハイフンは削除します。小文字に変換します。また、先頭と末尾の空白を取り除きます。
例:
```html+django
{{ value|slugify }}
```
`value` が `"Joel a slug"` であるとき、出力は `"Joel is a slug"` となります。
### `stringformat`
引数 (表示形式を指定する文字列) に応じて、変数の表示形式を変更します。指定方法には、[printf-style String Formatting](https://docs.python.org/3/library/stdtypes.html#old-string-formatting) シンタックスを使います。例外として、最初の ''%'' は無視されます。
例:
```html+django
{{ value|stringformat:"E" }}
```
例えば `value` が `10` の場合、出力は `1.000000E+01` となります。
### `striptags`
\[X\]HTML タグを全てはぎとるようにします。
例:
```html+django
{{ value|striptags }}
```
`value` が `"Joel a slug"` であるとき、出力は `"Joel is a slug"` となります。
> **安全性の保証はありません**
>
> 注意してください。 `striptags` の出力は HTML の安全性、特に不正な HTML の入力に対して何の保証もありません。 `striptags` の出力に `safe` フィルタを適用しては\*\*いけません\*\*。 より堅牢な方法を求めるならば、 Python の `bleach` ライブラリ、特に [clean](https://bleach.readthedocs.io/en/latest/clean.html) メソッドを使用できます。
### `time`
時刻を指定の書式にしたがってフォーマットします。
フォーマットは [`date`](#std-templatefilter-date) と同様に、あらかじめ定義された [`TIME_FORMAT`](/ja/2.2/ref/settings/#std-setting-TIME_FORMAT) のプリセット、またはカスタムフォーマットを使うこともできます。この定義はロケールに依存することに注意してください。
例:
```html+django
{{ value|time:"H:i" }}
```
`value` が `datetime.datetime.now()` の値であるとき、出力は `"01:23"` といった文字列になります。
Note that you can backslash-escape a format string if you want to use the
"raw" value. In this example, both "h" and "m" are backslash-escaped, because
otherwise each is a format string that displays the hour and the month,
respectively:
```html+django
{% value|time:"H\h i\m" %}
```
This would display as "01h 23m".
その他の例:
[`USE_L10N`](/ja/2.2/ref/settings/#std-setting-USE_L10N) が `True` で、[`LANGUAGE_CODE`](/ja/2.2/ref/settings/#std-setting-LANGUAGE_CODE) が例としてドイツ語を表す `"de"` だったとします:
```html+django
{{ value|time:"TIME_FORMAT" }}
```
the output will be the string `"01:23"` (The `"TIME_FORMAT"` format
specifier for the `de` locale as shipped with Django is `"H:i"`).
`time` フィルタが受け取る引数は、１日における時刻に関連したフォーマット文字列だけで、日付は受け付けません（理由は言うまでもありませんよね)。`日付` のフォーマットを行いたいときは、 [`date`](#std-templatefilter-date) フィルタを使ってください ( [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime) の値をすべて表示させたい場合は `time` とともに使います)。
上記のルールにはひとつ例外があります。タイムゾーン情報つきの `datetime` の値 (a [time-zone-aware](/ja/2.2/topics/i18n/timezones/#naive-vs-aware-datetimes) `datetime` instance) を渡した場合、 `time` フィルタはタイムゾーン関連の [format specifiers](#date-and-time-formatting-specifiers) である `'e'`、`'O'`、`'T'`、`'Z'` を受け付けます。
When used without a format string, the `TIME_FORMAT` format specifier is
used:
```html+django
{{ value|time }}
```
is the same as:
```html+django
{{ value|time:"TIME_FORMAT" }}
```
### `timesince`
日付を経過時間の形式にフォーマットします (例えば、 “4 days, 6 hours”) 。
オプションの引数として、比較対象とする時刻をとります (引数を省略すると *現在時刻* を使います)。例えば、 `blog_date` が 2006年 6月 1日 を表す日付オブジェクトで、`comment_date` が 2006年 6月 1日 08:00 を表す日時オブジェクトであるとき、以下のコードは "8 hours" を返します。
```html+django
{{ blog_date|timesince:comment_date }}
```
タイムゾーン情報を持たない値（offset-naive）と、タイムゾーン情報つき（offset-aware）の値とを比較した場合は、空の文字列を返します。
最小単位は "分" です。比較対象からみて未来にある日時に対しては "0 minutes" を返します。
### `timeuntil`
`timesince` に似ていますが、現在時刻を起点として指定の日付または日時までの時刻を計算します。例えば今日が 2006年 6月 1日で `conference_date` が 2006年 6月 29日の値を保持する日付インスタンスだったとすれば、 `{{ conference_date|timeuntil }}` は "4 weeks" を返します。
オプションの引数として、 (*現在時刻* の代わりに) 比較対象として使う時刻をとります。 例えば、 from\_date が 2006年 6月 22日 の場合、以下のコードは "1 week" を返します:
```html+django
{{ conference_date|timeuntil:from_date }}
```
タイムゾーン情報を持たない値（offset-naive）と、タイムゾーン情報つき（offset-aware）の値とを比較した場合は、空の文字列を返します。
最小単位は "分" です。比較対象からみて過去にある日時に対しては “0 minutes” を返します。
### `title`
文字列中の単語に対して、それぞれ先頭の文字を大文字に、残りを小文字にすることで文字列をタイトルケースに変換します。"主要でない単語" については小文字を維持できないこともあります。
例:
```html+django
{{ value|title }}
```
`value` が `"my FIRST post"` であるとき、出力は `"My First Post"` となります。
### `truncatechars`
Truncates a string if it is longer than the specified number of characters.
Truncated strings will end with a translatable ellipsis character ("…").
**引数:** 切り詰める文字数
例:
```html+django
{{ value|truncatechars:7 }}
```
If `value` is `"Joel is a slug"`, the output will be `"Joel i…"`.
### `truncatechars_html`
[`truncatechars`](#std-templatefilter-truncatechars) に似ていますが、 HTML タグを認識します。切り詰めを行う時点で閉じていないタグがあれば、切り詰めた文字の直後に全て閉じます。
例:
```html+django
{{ value|truncatechars_html:7 }}
```
If `value` is `"
Joel is a slug
"`, the output will be
`"
Joel i…
"`.
HTML コンテンツ内の改行は保持されます。
### `truncatewords`
文字列を指定された単語数以内に切り詰めます。
**引数:** 切り詰めた後の単語数
例:
```html+django
{{ value|truncatewords:2 }}
```
If `value` is `"Joel is a slug"`, the output will be `"Joel is …"`.
文字列中の改行は取り除かれます。
### `truncatewords_html`
[`truncatewords`](#std-templatefilter-truncatewords) に似ていますが、 HTML タグを認識します。切り詰めを行う時点で閉じていないタグがあれば、切り詰めた文字の直後に全て閉じます。
このタグの処理は [`truncatewords`](#std-templatefilter-truncatewords) よりも効率が悪いため、 HTML テキストを 渡す場合にだけ使うようにしてください。
例:
```html+django
{{ value|truncatewords_html:2 }}
```
If `value` is `"
```
ここで this\_value = 175 、 max\_value = 200 であるとき、画像の幅は 88 ピクセルになります (175 / 200 = .875、 .875 \* 100 = 87.5 から四捨五入して 88 )。
`widthratio` の結果を変数に入れてキャプチャーしたい場合があります。例えば [`blocktrans`](/ja/2.2/topics/i18n/translation/#std-templatetag-blocktrans) で使う場合、次のようにできます:
```html+django
{% widthratio this_value max_value max_width as width %}
{% blocktrans %}The width is: {{ width }}{% endblocktrans %}
```
### `with`
複雑な表現の変数の値をキャッシュし、簡単な名前で参照できるようにします。呼出しコストの高いメソッド (例えばデータベースを操作するようなメソッド) に何度もアクセスする際に便利です。
例:
```html+django
{% with total=business.employees.count %}
{{ total }} employee{{ total|pluralize }}
{% endwith %}
```
値を組み込んだ変数 (上の例でいえば `total` ) は `{% with %}` と `{% endwith %}` タグの間でだけ有効です。
コンテキスト変数は、複数割り当てることができます:
```html+django
{% with alpha=1 beta=2 %}
...
{% endwith %}
```
> **Note**
>
> 従来の冗長な書式もサポートされています: `{% with business.employees.count as total %}`
## 組み込みフィルタリファレンス
### `add`
入力値に対して引数の値を加算します。
例:
```html+django
{{ value|add:"2" }}
```
value が 4 なら、出力は 6 になるでしょう。
このフィルタは、まず両方の値を強制的に整数とみなして加算しようとします。失敗した場合は、とにかく値を足し合わせることを試みます。これはいくつかのデータ型 (文字列、リストなど) では動作しますが、それ以外では失敗します。失敗した場合、結果は空の文字列になります。
例として、次のようなフィルタがあるとしましょう:
```html+django
{{ first|add:second }}
```
`first` が `[1, 2, 3]` 、 `second` が `[4, 5, 6]` であった場合、出力は `[1, 2, 3, 4, 5, 6]` になります。
> **Warning**
>
> 整数に変換可能な文字列は、整数として「**加算**」されます。上の例のように「**結合**」されません。
### `addslashes`
引用符の前にスラッシュを追加します。CSV などの文字列をエスケープする際に便利です。
例:
```html+django
{{ value|addslashes }}
```
`value` の値が `"I'm using Django"` のとき、出力は `"I\'m using Django"` となります。
### `capfirst`
入力値の先頭の文字を大文字に変換します。最初の文字がアルファベットでなければ効果はありません。
例:
```html+django
{{ value|capfirst }}
```
If `value` is `"django"`, the output will be `"Django"`.
### `center`
入力値を引数で指定された幅のフィールド内に中央寄せします。
例:
```html+django
"{{ value|center:"15" }}"
```
`value` の値が `"django"` のとき、出力は `" Django "` となります。
### `cut`
入力値の中から、引数に指定した値を全て取り除きます。
例:
```html+django
{{ value|cut:" " }}
```
`value` の値が `"String with spaces"` のとき、出力は `"Stringwithspaces"` となります。
### `date`
引数に指定した書式で日付をフォーマットします。
いくつかの違いはありますが、フォーマットには PHP の `date()` 関数 ( 
```
値を何度も使う必要がある場合、不要な演算を回避するために使用できる第二の方式もあります:
```html+django
{% load static %}
{% get_static_prefix as STATIC_PREFIX %}
```
#### `get_media_prefix`
[`get_static_prefix`](#std-templatetag-get_static_prefix) と同じように、`get_media_prefix` はテンプレート変数に [`MEDIA_URL`](/ja/2.2/ref/settings/#std-setting-MEDIA_URL) のメディア・プレフィックスを加えます:
```html+django
{% load static %}
```
値をデータ・アトリビュートに格納することにより、これを JavaScript コンテキスト内で使用したい場合に適切なエスケープがなされていることが保証されます。