A view class that is used for JSON responses.
It allows you to omit templates if you just need to emit JSON string as response.
In your controller, you could do the following:
$this->set(['posts' => $posts]); $this->set('_serialize', true);
When the view is rendered, the $posts
view variable will be serialized into JSON.
You can also set multiple view variables for serialization. This will create a top level object containing all the named view variables:
$this->set(compact('posts', 'users', 'stuff')); $this->set('_serialize', true);
The above would generate a JSON object that looks like:
{"posts": [...], "users": [...]}
You can also set '_serialize'
to a string or array to serialize only the specified view variables.
If you don't use the _serialize
, you will need a view template. You can use extended views to provide layout-like functionality.
You can also enable JSONP support by setting parameter _jsonp
to true or a string to specify custom query string parameter name which will contain the callback function name.
_dataToSerialize( array|string|boolean $serialize true )
Returns data to be serialized.
$serialize
optional true mixed
_serialize( array|string|boolean $serialize )
Serialize view vars
_jsonOptions
You can set custom options for json_encode() this way, e.g. JSON_HEX_TAG | JSON_HEX_APOS
.
$serialize
string
render( string|null $view null , string|null $layout null )
Render a JSON view.
_serialize
To convert a set of view variables into a JSON response. Its value can be a string for single variable name or array for multiple names. If true all view variables will be serialized. It unset normal view template will be rendered. _jsonp
Enables JSONP support and wraps response in callback function provided in query string. - Setting it to true enables the default query string parameter "callback". - Setting it to a string value, uses the provided query string parameter for finding the JSONP callback name.
$view
optional null $layout
optional null string|null
Cake\Core\Exception\Exception
Cake\View\SerializedView::render()
__construct( Cake\Network\Request $request null , Cake\Network\Response $response null , Cake\Event\EventManager $eventManager null , array $viewOptions [] )
Constructor
Cake\Network\Request
$request
optional null Cake\Network\Response
$response
optional null Cake\Event\EventManager
$eventManager
optional null $viewOptions
optional [] Cake\View\View::__construct()
loadHelpers( )
Load helpers only if serialization is disabled.
Cake\View\View::loadHelpers()
__get( string $name )
Magic accessor for helpers.
$name
mixed
__set( string $name , mixed $value )
Magic setter for deprecated properties.
$name
$value
_checkFilePath( string $file , string $path )
Check that a view file path does not go outside of the defined template paths.
Only paths that contain ..
will be checked, as they are the ones most likely to have the ability to resolve to files outside of the template paths.
$file
$path
string
InvalidArgumentException
_elementCache( string $name , array $data , array $options )
Generate the cache configuration options for an element.
$name
$data
$options
array
_evaluate( string $viewFile , array $dataForView )
Sandbox method to evaluate a template / view script in.
$viewFile
$dataForView
string
_getElementFileName( string $name )
Finds an element filename, returns false on failure.
$name
string|false
_getLayoutFileName( string|null $name null )
Returns layout filename for this template as a string.
$name
optional null string
Cake\View\Exception\MissingLayoutException
_getSubPaths( string $basePath )
Find all sub templates path, based on $basePath If a prefix is defined in the current request, this method will prepend the prefixed template path to the $basePath, cascading up in case the prefix is nested. This is essentially used to find prefixed template paths for elements and layouts.
$basePath
array
_getViewFileName( string|null $name null )
Returns filename of given action's template file (.ctp) as a string. CamelCased action names will be under_scored by default. This means that you can have LongActionNames that refer to long_action_names.ctp views. You can change the inflection rule by overriding _inflectViewFileName.
$name
optional null string
Cake\View\Exception\MissingTemplateException
_inflectViewFileName( string $name )
Change the name of a view template file into underscored format.
$name
string
_paths( string|null $plugin null , boolean $cached true )
Return all possible paths to find view files in order
$plugin
optional null $cached
optional true array
_render( string $viewFile , array $data [] )
Renders and returns output for given template filename with its array of data. Handles parent/extended templates.
$viewFile
$data
optional [] string
LogicException
_renderElement( string $file , array $data , array $options )
Renders an element and fires the before and afterRender callbacks for it and writes to the cache if a cache is used
$file
$data
$options
string
append( string $name , mixed $value null )
Append to an existing or new block.
Appending to a new block will create the block.
$name
$value
optional null Cake\View\ViewBlock::concat()
assign( string $name , mixed $value )
Set the content for a block. This will overwrite any existing content.
$name
$value
Cake\View\ViewBlock::set()
autoLayout( boolean $autoLayout null )
Turns on or off CakePHP's conventional mode of applying layout files. On by default. Setting to off means that layouts will not be automatically applied to rendered templates.
$autoLayout
optional null boolean|null
blocks( )
Get the names of all the existing blocks.
array
Cake\View\ViewBlock::keys()
cache( callable $block , array $options [] )
Create a cached block of view logic.
This allows you to cache a block of view output into the cache defined in elementCache
.
This method will attempt to read the cache first. If the cache is empty, the $block will be run and the output stored.
$block
$options
optional [] string
RuntimeException
element( string $name , array $data [] , array $options [] )
Renders a piece of PHP with provided parameters and returns HTML, XML, or any other string.
This realizes the concept of Elements, (or "partial layouts") and the $params array is used to send data to be used in the element. Elements can be cached improving performance by using the cache
option.
$name
MyPlugin.template
to use the template element from MyPlugin. If the element is not found in the plugin, the normal view path cascade will be searched.$data
optional [] $options
optional [] cache
- Can either be true
, to enable caching using the config in View::$elementCache. Or an array If an array, the following keys can be used: - config
- Used to store the cached element in a custom cache configuration. - key
- Used to define the key used in the Cache::write(). It will be prefixed with element_
- callbacks
- Set to true to fire beforeRender and afterRender helper callbacks for this element. Defaults to false. - ignoreMissing
- Used to allow missing elements. Set to true to not throw exceptions.string
Cake\View\Exception\MissingElementException
ignoreMissing
is false.elementExists( string $name )
Checks if an element exists
$name
MyPlugin.template
to check the template element from MyPlugin. If the element is not found in the plugin, the normal view path cascade will be searched.boolean
end( )
End a capturing block. The compliment to View::start()
Cake\View\ViewBlock::end()
exists( string $name )
Check if a block exists
$name
boolean
extend( string $name )
Provides template or element extension/inheritance. Views can extends a parent view and populate blocks in the parent template.
$name
LogicException
LogicException
fetch( string $name , string $default '' )
Fetch the content for a block. If a block is empty or undefined '' will be returned.
$name
$default
optional '' string
Cake\View\ViewBlock::get()
get( string $var , mixed $default null )
Returns the contents of the given View variable.
$var
$default
optional null mixed
getVars( )
Returns a list of variables available in the current View context
array
helpers( )
Get the helper registry in use by this View class.
Cake\View\HelperRegistry
initialize( )
Initialization hook method.
Properties like $helpers etc. cannot be initialized statically in your custom view class as they are overwritten by values from controller in constructor. So this method allows you to manipulate them as required after view instance is constructed.
layout( string $name null )
Get/set the name of the layout file to render the template inside of. The name specified is the filename of the layout in /src/Template/Layout without the .ctp extension.
$name
optional null string|null
layoutPath( string $path null )
Get/set path for layout files.
$path
optional null string|null
loadHelper( string $name , array $config [] )
Loads a helper. Delegates to the HelperRegistry::load()
to load the helper
$name
$config
optional [] Cake\View\Helper
Cake\Core\ObjectRegistry::load()
pluginSplit( string $name , boolean $fallback true )
Splits a dot syntax plugin name into its plugin and filename. If $name does not have a dot, then index 0 will be null. It checks if the plugin is loaded, else filename will stay unchanged for filenames containing dot
$name
$fallback
optional true array
prepend( string $name , mixed $value )
Prepend to an existing or new block.
Prepending to a new block will create the block.
$name
$value
Cake\View\ViewBlock::concat()
renderLayout( string $content , string|null $layout null )
Renders a layout. Returns output from _render(). Returns false on error. Several variables are created for use in layout.
$content
$layout
optional null mixed
Cake\Core\Exception\Exception
reset( string $name )
Reset the content for a block. This will overwrite any existing content.
$name
Cake\View\ViewBlock::set()
start( string $name )
Start capturing output for a 'block'
You can use start on a block multiple times to append or prepend content in a capture mode.
// Append content to an existing block. $this->start('content'); echo $this->fetch('content'); echo 'Some new content'; $this->end(); // Prepend content to an existing block $this->start('content'); echo 'Some new content'; echo $this->fetch('content'); $this->end();
$name
Cake\View\ViewBlock::start()
template( string $name null )
Get/set the name of the template file to render. The name specified is the filename in /src/Template/<SubFolder> without the .ctp extension.
$name
optional null string|null
templatePath( string $path null )
Get/set path for templates files.
$path
optional null string|null
theme( string $theme null )
The view theme to use.
$theme
optional null string|null
uuid( string $object , string $url )
Generates a unique, non-random DOM ID for an object, based on the object type and the target URL.
$object
$url
string
_createCell( string $className , string $action , string $plugin , array $options )
Create and configure the cell instance.
$className
$action
$plugin
$options
Cake\View\Cell;
cell( string $cell , array $data [] , array $options [] )
Renders the given cell.
Example:
// Taxonomy\View\Cell\TagCloudCell::smallList() $cell = $this->cell('Taxonomy.TagCloud::smallList', ['limit' => 10]); // App\View\Cell\TagCloudCell::smallList() $cell = $this->cell('TagCloud::smallList', ['limit' => 10]);
The display
action will be used by default when no action is provided:
// Taxonomy\View\Cell\TagCloudCell::display() $cell = $this->cell('Taxonomy.TagCloud');
Cells are not rendered until they are echoed.
$cell
TagCloud::smallList
will invoke View\Cell\TagCloudCell::smallList()
, display
action will be invoked by default when none is provided.$data
optional [] cell('TagCloud::smallList', ['a1' => 'v1', 'a2' => 'v2'])
maps to View\Cell\TagCloud::smallList(v1, v2)
$options
optional [] Cake\View\Cell
Cake\View\Exception\MissingCellException
BadMethodCallException
dispatchEvent( string $name , array|null $data null , object|null $subject null )
Wrapper for creating and dispatching events.
Returns a dispatched event.
$name
$data
optional null $subject
optional null Cake\Event\Event
Cake\Event\EventDispatcherInterface::dispatchEvent()
eventManager( Cake\Event\EventManager $eventManager null )
Returns the Cake\Event\EventManager manager instance for this object.
You can use this instance to register any new listeners or callbacks to the object events, or create your own events and trigger them at will.
Cake\Event\EventManager
$eventManager
optional null Cake\Event\EventManager
Cake\Event\EventDispatcherInterface::eventManager()
log( mixed $msg , integer|string $level LogLevel::ERROR , string|array $context [] )
Convenience method to write a message to Log. See Log::write() for more information on writing to logs.
$msg
$level
optional LogLevel::ERROR $context
optional [] boolean
requestAction( string|array $url , array $extra [] )
Calls a controller's method from any location. Can be used to connect controllers together or tie plugins into a main application. requestAction can be used to return rendered views or fetch the return value from controller actions.
Under the hood this method uses Router::reverse() to convert the $url parameter into a string URL. You should use URL formats that are compatible with Router::reverse()
A basic example getting the return value of the controller action:
$variables = $this->requestAction('/articles/popular');
A basic example of request action to fetch a rendered page without the layout.
$viewHtml = $this->requestAction('/articles/popular', ['return']);
You can also pass the URL as an array:
$vars = $this->requestAction(['controller' => 'articles', 'action' => 'popular']);
You can pass POST, GET, COOKIE and other data into the request using the appropriate keys. Cookies can be passed using the cookies
key. Get parameters can be set with query
and post data can be sent using the post
key.
$vars = $this->requestAction('/articles/popular', [ 'query' => ['page' => 1], 'cookies' => ['remember_me' => 1], ]);
By default actions dispatched with this method will use the global $_SERVER and $_ENV values. If you want to override those values for a request action, you can specify the values:
$vars = $this->requestAction('/articles/popular', [ 'environment' => ['CONTENT_TYPE' => 'application/json'] ]);
By default actions dispatched with this method will use the standard session object. If you want a particular session instance to be used, you need to specify it.
$vars = $this->requestAction('/articles/popular', [ 'session' => new Session($someSessionConfig) ]);
$url
$extra
optional [] mixed
createView( string|null $viewClass null )
Constructs the view class instance based on the current configuration.
$viewClass
optional null Cake\View\View
Cake\View\Exception\MissingViewException
set( string|array $name , string|array|null|boolean $value null )
Saves a variable or an associative array of variables for use inside a template.
$name
$value
optional null mixed
viewBuilder( )
Get the view builder being used.
Cake\View\ViewBuilder
viewOptions( string|array|null $options null , boolean $merge true )
Get/Set valid view options in the object's _validViewOptions property. The property is created as an empty array if it is not set. If called without any parameters it will return the current list of valid view options. See createView()
.
$options
optional null $merge
optional true true
.array
TYPE_ELEMENT, TYPE_LAYOUT, TYPE_TEMPLATE, TYPE_VIEW |
protected string
The currently rendering view file. Used for resolving parent files.
null
protected string
Currently rendering an element. Used for finding parent fragments for elements.
''
protected array
List of variables to collect from the associated controller.
[ 'viewVars', 'autoLayout', 'helpers', 'template', 'layout', 'name', 'theme', 'layoutPath', 'templatePath', 'plugin', 'passedArgs' ]
protected array
Content stack, used for nested templates that all use View::extend();
[]
public boolean
Turns on or off CakePHP's conventional mode of applying layout files. On by default. Setting to off means that layouts will not be automatically applied to rendered templates.
true
public string
The Cache configuration View will use to store cached elements. Changing this will change the default configuration elements are stored under. You can also choose a cache config per element.
Cake\View\View::element()
'default'
public string
The name of the layout file to render the template inside of. The name specified is the filename of the layout in /src/Template/Layout without the .ctp extension.
'default'
public array
Current passed params. Passed to View from the creating Controller for convenience.
$this->request->params['pass']
instead.[]
public Cake\Network\Request
An instance of a Cake\Network\Request object that contains information about the current request. This object contains all the information about a request and several methods for reading additional information about the request.
public string
The name of the template file to render. The name specified is the filename in /src/Template/<SubFolder> without the .ctp extension.
null
public string
The name of the subfolder containing templates for this View.
null
protected Cake\Event\EventManager
Instance of the Cake\Event\EventManager this object is using to dispatch inner events.
null
public string
The name of default View class.
$this->viewBuilder()->className()
instead.null
public Cake\View\ViewBlock
public Cake\View\Helper\FlashHelper
public Cake\View\Helper\FormHelper
public Cake\View\Helper\HtmlHelper
public Cake\View\Helper\RssHelper
public Cake\View\Helper\TextHelper
public Cake\View\Helper\TimeHelper
public Cake\View\Helper\UrlHelper
© 2005–2016 The Cake Software Foundation, Inc.
Licensed under the MIT License.
CakePHP is a registered trademark of Cake Software Foundation, Inc.
We are not endorsed by or affiliated with CakePHP.
http://api.cakephp.org/3.1/class-Cake.View.JsonView.html