Page / $page

// Get a field value (output formatting ON by default in template context)
echo $page->title;
echo $page->body;
echo $page->get('title'); // same as $page->title

// Set a field value (turn off output formatting first)
$page->of(false);
$page->title = 'New Title';
$page->save('title'); // save just one field
$page->save();        // save all changed fields
$page->setAndSave('title', 'New Title'); // combined set + save

// Get raw unformatted value regardless of output formatting state
$raw = $page->getUnformatted('body');

// Get formatted value regardless of output formatting state
$formatted = $page->getFormatted('body');

// Get multiple values at once (returns array keyed by field name)
$values = $page->getMultiple(['title', 'body', 'images']);

Output formatting: of()

Output formatting determines whether field values pass through runtime text formatters (e.g. Markdown, HTML entities, etc.)

$page->of(false); // turn OFF — use when modifying values
$page->of(true);  // turn ON  — use for front-end output (default in template context)
$current = $page->of(); // returns current state (bool) without changing it

Always call $page->of(false) before setting and saving values. And if you will be making modifications to an existing value, make sure to $page->of(false) before getting the value you will modify. You do not want to have a formatted value get saved in the database.

Flexible get() syntax

get() accepts several formats beyond a plain field name:

// OR-pipe: return first non-empty value among listed fields
$page->get('summary|body|title');

// Dot notation: traverse into sub-objects
$page->get('category.title');       // title of related page
$page->get('images.first.url');     // url of first image

// Bracket notation: access items within a multi-value field
$page->get('images[]');             // all items as array
$page->get('images[0]');            // first item
$page->get('images[tag=hero]');     // item matching selector

// Format string: fill a pattern with property values
$page->get('{title} ({id})');

// Save all changed fields
$page->save();

// Save a specific field only
$page->save('title');
$page->saveFields(['title', 'body']); // save several fields

// Save without updating modified user and timestamp
$page->save(['quiet' => true]);

// Set value and save in one call, works even if output formatting on
$page->setAndSave('headline', 'Hello World');

// Set and save multiple fields
$page->setAndSave([
    'title' => 'It is Friday again',
    'subtitle' => 'The best day of the week is Friday',
    'body' => '<p>This is my short blog post...</p>'
]);

// Trash a page (moves to trash, recoverable)
$page->trash();

// Delete a page permanently
$page->delete();

// Delete a page and all its children
$page->delete(true);

Children and descendants

When we refer to "accessible" pages below, it means pages that are published, not hidden, and that the curent user has access to.

// Direct accessible children (published + visible + current user has access)
foreach($page->children() as $child) { ... }
$page->children('sort=title, limit=10'); // with selector

// First accessible child
$first = $page->child();

// First created and accessible child
$first = $page->child('sort=created');

// First created child with no exclusions (skips access and status checks)
$first = $page->child('sort=created, include=all');

// Last created child with no exclusions
$last = $page->child('sort=-created, include=all');

// Find among all accessible descendants, like $pages->find() but scoped to this page
$results = $page->find('template=product, featured=1');
$result  = $page->findOne('sku=ABC123');

// Number of children and descendants
$n = $page->numChildren();             // number of children with no exclusions
$n = $page->numChildren;               // same as above but as property
$n = $page->numChildren(true);         // number of accessible children
$n = $page->numChildren("foo=bar");    // count of children matching selector
$n = $page->numDescendants();          // number of descendants, no exclusions
$n = $page->numDescendants(true);      // number of accessible descendants
$n = $page->numDescendants("foo=bar"); // number of descendants matching selector

Parents and ancestors

All of the following method calls without arguments can also be accessed as properties, i.e. $page->parent() can also be accessed as $page->parent.

$parent = $page->parent();                     // immediate parent 
$parents = $page->parents();                   // all ancestors, root first
$parents = $page->parents('template=section'); // filtered ancestors
$root = $page->rootParent();                   // top-level ancestor
$n = $page->numParents();                      // depth in tree

Siblings

$siblings = $page->siblings();                 // all siblings including self
$siblings = $page->siblings(false);            // all siblings excluding self
$siblings = $page->siblings('sort=title');     // sorted siblings (or any selector)
$siblings = $page->siblings('foo=bar', false); // filtered siblings (excluding self)

$next = $page->next();                         // next sibling
$prev = $page->prev();                         // previous sibling
$next = $page->next('template=product');       // next matching sibling

$after  = $page->nextAll();                    // all following siblings
$after  = $page->nextAll('foo=bar');           // all following siblings, filtered
$before = $page->prevAll();                    // all preceding siblings

// All siblings up to (not including) first one matching the selector
$until = $page->nextUntil('template=divider');
$until = $page->prevUntil('template=divider');

Position

$n = $page->index();        // 0-based position among accessible siblings
$n = $page->index(true);    // same as above but with no exclusions

// Test page against a selector in memory (no DB query)
if($page->matches('created>=today')) { ... }
if($page->matches('template=product, featured=1')) { ... }

// Test page against a selector via database query
if($page->matchesDatabase('title=Hello')) { ... }

// Conditional output shorthand
echo $page->if('featured', '<b>Featured</b>');
echo $page->if('featured=1', '<b>Yes</b>', '<b>No</b>');

The following may be accessed as methods or properties.

$page->url();     // URL path (e.g. /about/team/)
$page->path();    // like url() but without installation subdir (if applicable)
$page->httpUrl(); // with scheme+host (e.g. https://example.com/about/team/)
$page->editUrl(); // admin edit URL

// Get all URL variants (useful for language or multi-domain setups)
$urls = $page->urls();  // returns object with url, httpUrl, edit, etc.

// urlOptions used internally by traversal methods

// Does the page's template include this field?
if($page->hasField('body')) { ... }

// Get the Field object for a field
$field = $page->getField('body');

// Get all Field objects for this page's template
foreach($page->getFields() as $field) { echo $field->name; }

The following methods are added at runtime by the PagePermissions module (installed by default). They respect the current $user and the page's access template.

if($page->viewable()) { ... }         // is page viewable by current user?
if($page->editable()) { ... }         // is page editable by current user?
if($page->publishable()) { ... }      // can current user publish this page?
if($page->listable()) { ... }         // is page listable by current user?
if($page->deleteable()) { ... }       // can current user delete this page?
if($page->trashable()) { ... }        // can current user trash this page?
if($page->addable()) { ... }          // can current user add children?
if($page->addable('product')) { ... } // can current user add a child of given template?
if($page->moveable()) { ... }         // can current user move this page?
if($page->sortable()) { ... }         // can current user change sort of this page?
if($page->cloneable()) { ... }        // can current user clone this page?

Lower-level access methods (always available):

If a page's template does not define access control then the page will inherit its access control from one of its parents. The following methods return the page that the current one inherits its access control from, whether the page itself, or a parent.

$accessTemplate = $page->getAccessTemplate();    // Template that controls access
$accessParent   = $page->getAccessParent();      // Page that provides access settings
$roles          = $page->getAccessRoles();       // WireArray of Roles with view access
if($page->hasAccessRole($role)) { ... }

// Render page using its template file (returns string)
echo $page->render();

// Render a field using a site/templates/fields/ file
echo $page->renderField('body');
echo $page->renderField('images', 'gallery'); // with custom file
echo $page->render('images');                 // alias of renderField

// Render field via property syntax
echo $page->render->images;
echo $page->_images_;               // double-underscore shorthand

// Get markup for a field (uses Fieldtype::markupValue)
echo $page->getMarkup('body');

// Get plain text (applies entity decoding when output formatting on)
$text = $page->getText('body');
$text = $page->getText('body', true); // require 1-line value
$text = $page->getText('body', true, false); // 1-line value, entities off

// Front-end editable field (requires PageFrontEdit module)
echo $page->edit('body');

// getMarkup() with format string — fills {tag} placeholders from page fields
echo $page->getMarkup('{title} — {summary}');

// Pages that reference this page via a Page-type field
$refs = $page->references();
$refs = $page->references('template=news');     // filtered

// Pages that this page references via Page-type fields
$linking = $page->referencing();
$linking = $page->referencing('template=category');

// Pages linked from this page's text/HTML content (where possible to detect)
$linked = $page->links();
$linked = $page->links('template=product');

// Preload one or more field values into this page (avoids repeated lazy-load queries)
$page->preload('body');
$page->preload(['body', 'images', 'sidebar']);

When $pages->get() or traversal methods find no result, they return a NullPage rather than null. A NullPage has id === 0.

$page = $pages->get('template=product, sku=MISSING');
if($page->id) {
    // found
} else {
    // not found — $page is a NullPage
}

if($page instanceof NullPage) {
    // not found — $page is a NullPage
}

// Case where $page can be `null` or `NullPage`
if("$page") { ... } // page is not null and has id=0 (NullPage)

// Do NOT do:
if($page) { ... }      // Page object is always truthy — even NullPage

A page's type is typically identified by its template…

if($page->template->name === 'product') {
    // Page is a 'product' page
}

…but when using custom page classes, you can also identify a page by its class type:

if($page instanceof ProductPage) {
    // Page is a 'product' page
}

• $page->of(false) must be called before setting or saving field values; skipping it can corrupt formatted values (e.g. saving HTML-encoded entities back to the DB).
• $page->children(), $page->find() and similar methods exclude hidden, unpublished, and inaccessible pages by default. Add include=hidden, include=unpublished, or include=all to the selector to override.
• Status is a bitmask integer. Multiple statuses are combined with |: Page::statusHidden | Page::statusUnpublished.
• statusCorrupted is a runtime-only flag. If present, ProcessWire refuses to save the page to protect against writing corrupt data.
• The Page class delegates most of its method implementations to helper classes in wire/core/Page/. The main class file is wire/core/Page/Page.php.