エントリクエリ

エントリクエリを使用して、テンプレートや PHP コード内でエントリを取得できます。

{# Create a new entry query #}
{% set myEntryQuery = craft.entries() %}

エレメントクエリを作成すると、結果を絞り込むためのパラメータをセットできます。さらに、 .all() を呼び出して実行できます。Entry オブジェクトの配列が返されます。

TIP

エレメントクエリがどのように機能するかについては、エレメントクエリについてを参照してください。

実例

次の操作を行うことで、「Blog」セクションに含まれる最新10件のエントリを表示できます。

  1. craft.entries() でエントリクエリを作成します。
  2. section および limit パラメータをセットします。
  3. .all() でエントリを取得します。
  4. for タグを使用してエントリをループ処理し、ブログ投稿の HTML を出力します。
{# Create an entry query with the 'section' and 'limit' parameters #}
{% set myEntryQuery = craft.entries()
    .section('blog')
    .limit(10) %}

{# Fetch the entries #}
{% set entries = myEntryQuery.all() %}

{# Display the entries #}
{% for entry in entries %}
    <article>
        <h1><a href="{{ entry.url }}">{{ entry.title }}</a></h1>
        {{ entry.summary }}
        <a href="{{ entry.url }}">Continue reading</a>
    </article>
{% endfor %}

パラメータ

エントリクエリは、次のパラメータをサポートしています。

after

特定の日付以降に投稿されたエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'2018-04-01'2018-04-01 以降に投稿されたもの。
DateTime オブジェクトオブジェクトとして表される日付以降に投稿されたもの。
{# Fetch entries posted this month #}
{% set firstDayOfMonth = date('first day of this month') %}

{% set entries = craft.entries()
    .after(firstDayOfMonth)
    .all() %}

ancestorDist

ancestorOf で指定されたエントリから特定の距離だけ離れているエントリのみに、クエリの結果を絞り込みます。

{# Fetch entries above this one #}
{% set entries = craft.entries()
    .ancestorOf(myEntry)
    .ancestorDist(3)
    .all() %}

ancestorOf

指定したエントリの先祖であるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの上層。
Entry オブジェクトオブジェクトで表されるエントリの上層。
{# Fetch entries above this one #}
{% set entries = craft.entries()
    .ancestorOf(myEntry)
    .all() %}

TIP

どれだけ離れた先祖エントリを対象にするか制限したい場合、ancestorDist と組み合わせることができます。

anyStatus

status および enabledForSite パラメータをクリアします。

{# Fetch all entries, regardless of status #}
{% set entries = craft.entries()
    .anyStatus()
    .all() %}

asArray

Entry オブジェクトではなく、データの配列として、マッチしたエントリをクエリが返します。

{# Fetch entries as arrays #}
{% set entries = craft.entries()
    .asArray()
    .all() %}

authorGroup

エントリの投稿者が属するユーザーグループに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'ハンドルが foo のグループ内の投稿者。
'not foo'ハンドルが foo のグループ内の投稿者ではない。
['foo', 'bar']ハンドルが foo または bar のグループ内の投稿者。
['not', 'foo', 'bar']ハンドルが foo または bar のグループ内の投稿者ではない。
UserGroup オブジェクトオブジェクトで表されるグループ内の投稿者。
{# Fetch entries with an author in the Foo user group #}
{% set entries = craft.entries()
    .authorGroup('foo')
    .all() %}

authorGroupId

グループの ID ごとに、エントリの投稿者が属するユーザーグループに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のグループ内の投稿者。
'not 1'ID が 1 のグループ内の投稿者ではない。
[1, 2]ID が 1 または 2 のグループ内の投稿者。
['not', 1, 2]ID が 1 または 2 のグループ内の投稿者ではない。
{# Fetch entries with an author in a group with an ID of 1 #}
{% set entries = craft.entries()
    .authorGroupId(1)
    .all() %}

authorId

エントリの投稿者に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 の投稿者。
'not 1'ID が 1 の投稿者ではない。
[1, 2]ID が 1 または 2 の投稿者。
['not', 1, 2]ID が 1 または 2 の投稿者ではない。
{# Fetch entries with an author with an ID of 1 #}
{% set entries = craft.entries()
    .authorId(1)
    .all() %}

before

特定の日付より前に投稿されたエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'2018-04-01'2018-04-01 より前に投稿されたもの。
DateTime オブジェクトオブジェクトで表される日付より前に投稿されたもの。
{# Fetch entries posted before this month #}
{% set firstDayOfMonth = date('first day of this month') %}

{% set entries = craft.entries()
    .before(firstDayOfMonth)
    .all() %}

dateCreated

エントリの作成日に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'>= 2018-04-01'2018-04-01 以降に作成されたもの。
'< 2018-05-01'2018-05-01 より前に作成されたもの。
['and', '>= 2018-04-04', '< 2018-05-01']2018-04-01 から 2018-05-01 の間に作成されたもの。
{# Fetch entries created last month #}
{% set start = date('first day of last month')|atom %}
{% set end = date('first day of this month')|atom %}

{% set entries = craft.entries()
    .dateCreated(['and', ">= #{start}", "< #{end}"])
    .all() %}

dateUpdated

エントリの最終アップデート日に基づいて、クエリの結果が絞り込まれます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'>= 2018-04-01'2018-04-01 以降にアップデートされたもの。
'< 2018-05-01'2018-05-01 より前にアップデートされたもの。
['and', '>= 2018-04-04', '< 2018-05-01']2018-04-01 から 2018-05-01 の間にアップデートされたもの。
{# Fetch entries updated in the last week #}
{% set lastWeek = date('1 week ago')|atom %}

{% set entries = craft.entries()
    .dateUpdated(">= #{lastWeek}")
    .all() %}

descendantDist

descendantOf で指定されたエントリから特定の距離だけ離れているエントリのみに、クエリの結果を絞り込みます。

{# Fetch entries below this one #}
{% set entries = craft.entries()
    .descendantOf(myEntry)
    .descendantDist(3)
    .all() %}

descendantOf

指定したエントリの子孫であるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のカテゴリの下層。
Entry オブジェクトオブジェクトで表されるエントリの下層。
{# Fetch entries below this one #}
{% set entries = craft.entries()
    .descendantOf(myEntry)
    .all() %}

TIP

どれだけ離れた子孫エントリを対象にするか制限したい場合、descendantDist と組み合わせることができます。

enabledForSite

site パラメータごとに、照会されているサイトでエントリが有効になっているかどうかに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
true(デフォルト)サイト内で有効になっているもの。
falseサイト内で有効かどうかに関係なく。
{# Fetch all entries, including ones disabled for this site #}
{% set entries = craft.entries()
    .enabledForSite(false)
    .all() %}

expiryDate

エントリの有効期限日に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
':empty:'有効期限日を持たない。
':notempty:'有効期限日を持つ。
'>= 2020-04-01'2020-04-01 以降に有効期限が切れるもの。
'< 2020-05-01'2020-05-01 より前に有効期限が切れるもの。
['and', '>= 2020-04-04', '< 2020-05-01']2020-04-01 から 2020-05-01 の間に有効期限が切れるもの。
{# Fetch entries expiring this month #}
{% set nextMonth = date('first day of next month')|atom %}

{% set entries = craft.entries()
    .expiryDate("< #{nextMonth}")
    .all() %}

fixedOrder

クエリの結果を id で指定された順序で返します。

{# Fetch entries in a specific order #}
{% set entries = craft.entries()
    .id([1, 2, 3, 4, 5])
    .fixedOrder()
    .all() %}

hasDescendants

エントリが子孫を持つかどうかに基づいて、クエリの結果を絞り込みます。

(これは leaves の呼び出しと反対の効果を持っています。)

{# Fetch entries that have descendants #}
{% set entries = craft.entries()
    .hasDescendants()
    .all() %}

id

エントリの ID に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1。
'not 1'ID が 1ではない。
[1, 2]ID が 1 または 2。
['not', 1, 2]ID が 1 または 2 ではない。
{# Fetch the entry by its ID #}
{% set entry = craft.entries()
    .id(1)
    .one() %}

TIP

特定の順序で結果を返したい場合、fixedOrder と組み合わせることができます。

inReverse

クエリの結果を逆順で返します。

{# Fetch entries in reverse #}
{% set entries = craft.entries()
    .inReverse()
    .all() %}

leaves

エントリが「leaves」(子孫のないエントリ)であるかどうかに基づいて、クエリの結果を絞り込みます。

(これは hasDescendants の呼び出しと反対の効果を持っています。)

{# Fetch entries that have no descendants #}
{% set entries = craft.entries()
    .leaves()
    .all() %}

level

構造内のエントリのレベルに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1レベルが 1。
'not 1'レベルが 1 ではない。
'>= 3'レベルが 3 以上。
[1, 2]レベルが 1 または 2。
['not', 1, 2]レベルが 1 または 2 ではない。
{# Fetch entries positioned at level 3 or above #}
{% set entries = craft.entries()
    .level('>= 3')
    .all() %}

limit

返されるエントリの数を決定します。

{# Fetch up to 10 entries  #}
{% set entries = craft.entries()
    .limit(10)
    .all() %}

nextSiblingOf

指定したエントリの直後にあるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの後。
Entry オブジェクトオブジェクトで表されるエントリの後。
{# Fetch the next entry #}
{% set entry = craft.entries()
    .nextSiblingOf(myEntry)
    .one() %}

offset

結果からスキップされるエントリの数を決定します。

{# Fetch all entries except for the first 3 #}
{% set entries = craft.entries()
    .offset(3)
    .all() %}

orderBy

返されるエントリの順序を決定します。

{# Fetch all entries in order of date created #}
{% set entries = craft.entries()
    .orderBy('dateCreated asc')
    .all() %}

positionedAfter

指定したエントリの後に位置するエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの後。
Entry オブジェクトオブジェクトで表されるエントリの後。
{# Fetch entries after this one #}
{% set entries = craft.entries()
    .positionedAfter(myEntry)
    .all() %}

positionedBefore

指定したエントリの前に位置するエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの前。
Entry オブジェクトオブジェクトで表されるエントリの前。
{# Fetch entries before this one #}
{% set entries = craft.entries()
    .positionedBefore(myEntry)
    .all() %}

postDate

エントリの投稿日に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'>= 2018-04-01'2018-04-01 以降に投稿されたもの。
'< 2018-05-01'2018-05-01 より前に投稿されたもの。
['and', '>= 2018-04-04', '< 2018-05-01']2018-04-01 と 2018-05-01 の間に投稿されたもの。
{# Fetch entries posted last month #}
{% set start = date('first day of last month')|atom %}
{% set end = date('first day of this month')|atom %}

{% set entries = craft.entries()
    .postDate(['and', ">= #{start}", "< #{end}"])
    .all() %}

prevSiblingOf

指定したエントリの直前にあるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの前。
Entry オブジェクトオブジェクトで表されるエントリの前。
{# Fetch the previous entry #}
{% set entry = craft.entries()
    .prevSiblingOf(myEntry)
    .one() %}

relatedTo

特定の他のエレメントと関連付けられたエントリだけに、クエリの結果を絞り込みます。

このパラメーターがどのように機能するかの詳細については、リレーションを参照してください。

{# Fetch all entries that are related to myCategory #}
{% set entries = craft.entries()
    .relatedTo(myCategory)
    .all() %}

検索クエリにマッチするエントリだけに、クエリの結果を絞り込みます。

このパラメーターがどのように機能するかの詳細については、検索を参照してください。

{# Get the search query from the 'q' query string param #}
{% set searchQuery = craft.app.request.getQueryParam('q') %}

{# Fetch all entries that match the search query #}
{% set entries = craft.entries()
    .search(searchQuery)
    .all() %}

section

エントリが属するセクションに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'ハンドルが foo のセクション内。
'not foo'ハンドルが foo のセクション内ではない。
['foo', 'bar']ハンドルが foo または bar のセクション内。
['not', 'foo', 'bar']ハンドルが foo または bar のセクション内ではない。
Section オブジェクトオブジェクトで表されるセクション内。
{# Fetch entries in the Foo section #}
{% set entries = craft.entries()
    .section('foo')
    .all() %}

sectionId

セクションの ID ごとに、エントリが属するセクションに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のセクション内。
'not 1'ID が 1 のセクション内ではない。
[1, 2]ID が 1 または 2 のセクション内。
['not', 1, 2]ID が 1 または 2 のセクション内ではない。
{# Fetch entries in the section with an ID of 1 #}
{% set entries = craft.entries()
    .sectionId(1)
    .all() %}

siblingOf

指定したエントリの兄弟であるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの横。
Entry オブジェクトオブジェクトで表されるエントリの横。
{# Fetch entries beside this one #}
{% set entries = craft.entries()
    .siblingOf(myEntry)
    .all() %}

site

エントリを照会するサイトを決定します。

デフォルトでは、現在のサイトが使用されます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'ハンドルが foo のサイトから。
\craft\elements\db\Site オブジェクトオブジェクトで表されるサイトから。
{# Fetch entries from the Foo site #}
{% set entries = craft.entries()
    .site('foo')
    .all() %}

siteId

サイトの ID ごとに、エントリを照会するサイトを決定します。

デフォルトでは、現在のサイトが使用されます。

{# Fetch entries from the site with an ID of 1 #}
{% set entries = craft.entries()
    .siteId(1)
    .all() %}

slug

エントリのスラグに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'スラグが foo
'foo*'スラグが foo ではじまる。
'*foo'スラグが foo で終わる。
'*foo*'スラグが foo を含む。
'not *foo*'スラグが foo を含まない。
['*foo*', '*bar*']スラグが foo または bar を含む。
['not', '*foo*', '*bar*']スラグが foo または bar を含まない。
{# Get the requested entry slug from the URL #}
{% set requestedSlug = craft.app.request.getSegment(3) %}

{# Fetch the entry with that slug #}
{% set entry = craft.entries()
    .slug(requestedSlug|literal)
    .one() %}

status

エントリのステータスに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'live'(デフォルト)公開しているもの。
'pending'保留しているもの(未来の投稿日がセットされた有効なもの)。
'expired'期限切れのもの(過去の有効期限日がセットされた有効なもの)。
'disabled'無効なもの。
['live', 'pending']live または pending のもの。
{# Fetch disabled entries #}
{% set entries = {twig-function}
    .status('disabled')
    .all() %}

title

エントリのタイトルに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'Foo'タイトルが Foo
'Foo*'タイトルが Foo ではじまる。
'*Foo'タイトルが Foo で終わる。
'*Foo*'タイトルが Foo を含む。
'not *Foo*'タイトルが Foo を含まない。
['*Foo*', '*Bar*']タイトルが Foo または Bar を含む。
['not', '*Foo*', '*Bar*']タイトルが Foo または Bar を含まない。
{# Fetch entries with a title that contains "Foo" #}
{% set entries = craft.entries()
    .title('*Foo*')
    .all() %}

trashed

ソフトデリートされたエントリだけに、クエリの結果を絞り込みます。

{# Fetch trashed entries #}
{% set entries = {twig-function}
    .trashed()
    .all() %}

type

エントリの入力タイプに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'ハンドルが foo のタイプ。
'not foo'ハンドルが foo のタイプではない。
['foo', 'bar']ハンドルが foo または bar のタイプ。
['not', 'foo', 'bar']ハンドルが foo または bar のタイプではない。
EntryType オブジェクトオブジェクトで表されるタイプ。
{# Fetch entries in the Foo section with a Bar entry type #}
{% set entries = craft.entries()
    .section('foo')
    .type('bar')
    .all() %}

typeId

タイプの ID ごとに、エントリの入力タイプに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のタイプ。
'not 1'ID が 1 のタイプではない。
[1, 2]ID が 1 または 2 のタイプ。
['not', 1, 2]ID が 1 または 2 のタイプではない。
{# Fetch entries of the entry type with an ID of 1 #}
{% set entries = craft.entries()
    .typeId(1)
    .all() %}

uid

エントリの UID に基づいて、クエリの結果を絞り込みます。

{# Fetch the entry by its UID #}
{% set entry = craft.entries()
    .uid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
    .one() %}

uri

エントリの URI に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'URI が foo
'foo*'URI が foo ではじまる。
'*foo'URI が foo で終わる。
'*foo*'URI が foo を含む。
'not *foo*'URI が foo を含まない。
['*foo*', '*bar*']URI が foo または bar を含む。
['not', '*foo*', '*bar*']URI が foo または bar を含まない。
{# Get the requested URI #}
{% set requestedUri = craft.app.request.getPathInfo() %}

{# Fetch the entry with that URI #}
{% set entry = craft.entries()
    .uri(requestedUri|literal)
    .one() %}

with

関連付けられたエレメントを eager-loaded した状態で、マッチしたエントリをクエリが返します。

このパラメーターがどのように機能するかの詳細については、エレメントのEager-Loadingを参照してください。

{# Fetch entries eager-loaded with the "Related" field’s relations #}
{% set entries = craft.entries()
    .with(['related'])
    .all() %}