Toolbox for developers / PHP online test

PHP syntax checker

PHP tester allows to check your PHP code syntax, and find PHP errors easily and quickly. This PHP code checker tool highlights and goes to line with a syntax error.

To check your code, you must copy and paste, drag and drop a PHP file or directly type in the "PHP code" online editor below, and click on "Check PHP syntax" button.

You can see the user guide to help you to use this php checker tool.


PHP code




PHP version for code checker



User guide

To check syntax code:

  • First, Drag and drop your PHP file or copy / paste your PHP text directly into the editor above.
  • Finally, you must click on "Check PHP syntax" button to display if there is an syntax error in your code.


PHP code checker tool

PHP is a server-side scripting language, but can also be used as a general-purpose programming language.

PHP error checker tool allows to find syntax errors (lint). You can test your PHP code online directly in your browser.

If a syntax error is detected, then the line in error is highlighted, and it jumps to it to save time (no need to search the line).

It can be useful to make online test to save time (deployment ...).

Note: This tool no longer offers sandbox, it was not good enough.


About PHP

PHP (recursive acronym for PHP: Hypertext Preprocessor) is a server-side scripting language especially suited for web development.PHP script can be embedded into HTML. PHP can also be used as a general-purpose programming language.

PHP has become popular among Web Developers thanks to its advantages: Simplicity, Free, Flexible and Scalable, CMS, Vast Community ...



You can report a bug or give feedback by adding a comment (below) or by clicking "Contact me" link (at the top right hand corner of the page).

Comments




Anonymous-2019-05-20 06:55

/**
* Modular Extensions - HMVC
*
* Adapted from the CodeIgniter Core Classes
* @link http://codeigniter.com
*
* Description:
* This library extends the CodeIgniter CI_Loader class
* and adds features allowing use of modules and the HMVC design pattern.
*
* Install this file as application/third_party/MX/Loader.php
*
* @copyright Copyright (c) 2011 Wiredesignz
* @version 5.4
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
**/
class MX_Loader extends CI_Loader
{
protected $_module;

public $_ci_plugins = array();
public $_ci_cached_vars = array();

/** Initialize the loader variables **/
public function initialize($controller = NULL) {

/* set the module name */
$this->_module = CI::$APP->router->fetch_module();

if (is_a($controller, 'MX_Controller')) {

/* reference to the module controller */
$this->controller = $controller;

/* references to ci loader variables */
foreach (get_class_vars('CI_Loader') as $var => $val) {
if ($var != '_ci_ob_level') {
$this->$var =& CI::$APP->load->$var;
}
}

} else {
parent::initialize();

/* autoload module items */
$this->_autoloader(array());
}

/* add this module path to the loader variables */
$this->_add_module_paths($this->_module);
}

/** Add a module path loader variables **/
public function _add_module_paths($module = '') {

if (empty($module)) return;

foreach (Modules::$locations as $location => $offset) {

/* only add a module path if it exists */
if (is_dir($module_path = $location.$module.'/') && ! in_array($module_path, $this->_ci_model_paths))
{
array_unshift($this->_ci_model_paths, $module_path);
}
}
}

/** Load a module config file **/
public function config($file = 'config', $use_sections = FALSE, $fail_gracefully = FALSE) {
return CI::$APP->config->load($file, $use_sections, $fail_gracefully, $this->_module);
}

/** Load the database drivers **/
public function database($params = '', $return = FALSE, $active_record = NULL) {

if (class_exists('CI_DB', FALSE) AND $return == FALSE AND $active_record == NULL AND isset(CI::$APP->db) AND is_object(CI::$APP->db))
return;

require_once BASEPATH.'database/DB'.EXT;

if ($return === TRUE) return DB($params, $active_record);

CI::$APP->db = DB($params, $active_record);

return CI::$APP->db;
}

/** Load a module helper **/
public function helper($helper = array()) {

if (is_array($helper)) return $this->helpers($helper);

if (isset($this->_ci_helpers[$helper])) return;

list($path, $_helper) = Modules::find($helper.'_helper', $this->_module, 'helpers/');

if ($path === FALSE) return parent::helper($helper);

Modules::load_file($_helper, $path);
$this->_ci_helpers[$_helper] = TRUE;
}

/** Load an array of helpers **/
public function helpers($helpers = array()) {
foreach ($helpers as $_helper) $this->helper($_helper);
}

/** Load a module language file **/
public function language($langfile = array(), $idiom = '', $return = FALSE, $add_suffix = TRUE, $alt_path = '') {
return CI::$APP->lang->load($langfile, $idiom, $return, $add_suffix, $alt_path, $this->_module);
}

public function languages($languages) {
foreach($languages as $_language) $this->language($_language);
}

/** Load a module library **/
public function library($library = '', $params = NULL, $object_name = NULL) {

if (is_array($library)) return $this->libraries($library);

$class = strtolower(basename($library));

if (isset($this->_ci_classes[$class]) AND $_alias = $this->_ci_classes[$class])
return CI::$APP->$_alias;

($_alias = strtolower($object_name)) OR $_alias = $class;

list($path, $_library) = Modules::find($library, $this->_module, 'libraries/');

/* load library config file as params */
if ($params == NULL) {
list($path2, $file) = Modules::find($_alias, $this->_module, 'config/');
($path2) AND $params = Modules::load_file($file, $path2, 'config');
}

if ($path === FALSE) {

$this->_ci_load_class($library, $params, $object_name);
$_alias = $this->_ci_classes[$class];

} else {

Modules::load_file($_library, $path);

$library = ucfirst($_library);
CI::$APP->$_alias = new $library($params);

$this->_ci_classes[$class] = $_alias;
}

return CI::$APP->$_alias;
}

/** Load an array of libraries **/
public function libraries($libraries) {
foreach ($libraries as $_library) $this->library($_library);
}

/** Load a module model **/
public function model($model, $object_name = NULL, $connect = FALSE) {

if (is_array($model)) return $this->models($model);

($_alias = $object_name) OR $_alias = basename($model);

if (in_array($_alias, $this->_ci_models, TRUE))
return CI::$APP->$_alias;

/* check module */
list($path, $_model) = Modules::find(strtolower($model), $this->_module, 'models/');

if ($path == FALSE) {

/* check application & packages */
parent::model($model, $object_name, $connect);

} else {

class_exists('CI_Model', FALSE) OR load_class('Model', 'core');

if ($connect !== FALSE AND ! class_exists('CI_DB', FALSE)) {
if ($connect === TRUE) $connect = '';
$this->database($connect, FALSE, TRUE);
}

Modules::load_file($_model, $path);

$model = ucfirst($_model);
CI::$APP->$_alias = new $model();

$this->_ci_models[] = $_alias;
}

return CI::$APP->$_alias;
}

/** Load an array of models **/
public function models($models) {
foreach ($models as $_model) $this->model($_model);
}

/** Load a module controller **/
public function module($module, $params = NULL) {

if (is_array($module)) return $this->modules($module);

$_alias = strtolower(basename($module));
CI::$APP->$_alias = Modules::load(array($module => $params));
return CI::$APP->$_alias;
}

/** Load an array of controllers **/
public function modules($modules) {
foreach ($modules as $_module) $this->module($_module);
}

/** Load a module plugin **/
public function plugin($plugin) {

if (is_array($plugin)) return $this->plugins($plugin);

if (isset($this->_ci_plugins[$plugin]))
return;

list($path, $_plugin) = Modules::find($plugin.'_pi', $this->_module, 'plugins/');

if ($path === FALSE AND ! is_file($_plugin = APPPATH.'plugins/'.$_plugin.EXT)) {
show_error("Unable to locate the plugin file: {$_plugin}");
}

Modules::load_file($_plugin, $path);
$this->_ci_plugins[$plugin] = TRUE;
}

/** Load an array of plugins **/
public function plugins($plugins) {
foreach ($plugins as $_plugin) $this->plugin($_plugin);
}

/** Load a module view **/
public function view($view, $vars = array(), $return = FALSE) {
list($path, $_view) = Modules::find($view, $this->_module, 'views/');

if ($path != FALSE) {
$this->_ci_view_paths = array($path => TRUE) + $this->_ci_view_paths;
$view = $_view;
}

return $this->_ci_load(array('_ci_view' => $view, '_ci_vars' => $this->_ci_object_to_array($vars), '_ci_return' => $return));
}

public function _ci_is_instance() {}

protected function &_ci_get_component($component) {
return CI::$APP->$component;
}

public function __get($class) {
return (isset($this->controller)) ? $this->controller->$class : CI::$APP->$class;
}

public function _ci_load($_ci_data) {

extract($_ci_data);

if (isset($_ci_view)) {

$_ci_path = '';

/* add file extension if not provided */
$_ci_file = (pathinfo($_ci_view, PATHINFO_EXTENSION)) ? $_ci_view : $_ci_view.EXT;

foreach ($this->_ci_view_paths as $path => $cascade) {
if (file_exists($view = $path.$_ci_file)) {
$_ci_path = $view;
break;
}

if ( ! $cascade) break;
}

} elseif (isset($_ci_path)) {

$_ci_file = basename($_ci_path);
if( ! file_exists($_ci_path)) $_ci_path = '';
}

if (empty($_ci_path))
show_error('Unable to load the requested file: '.$_ci_file);

if (isset($_ci_vars))
$this->_ci_cached_vars = array_merge($this->_ci_cached_vars, (array) $_ci_vars);

extract($this->_ci_cached_vars);

ob_start();

if ((bool) @ini_get('short_open_tag') === FALSE AND CI::$APP->config->item('rewrite_short_tags') == TRUE) {
echo eval('?>'.preg_replace("/;*\s*\?>/", "; ?>", str_replace(' } else {
include($_ci_path);
}

log_message('debug', 'File loaded: '.$_ci_path);

if ($_ci_return == TRUE) return ob_get_clean();

if (ob_get_level() > $this->_ci_ob_level + 1) {
ob_end_flush();
} else {
CI::$APP->output->append_output(ob_get_clean());
}
}

/** Autoload module items **/
public function _autoloader($autoload) {

$path = FALSE;

if ($this->_module) {

list($path, $file) = Modules::find('constants', $this->_module, 'config/');

/* module constants file */
if ($path != FALSE) {
include_once $path.$file.EXT;
}

list($path, $file) = Modules::find('autoload', $this->_module, 'config/');

/* module autoload file */
if ($path != FALSE) {
$autoload = array_merge(Modules::load_file($file, $path, 'autoload'), $autoload);
}
}

/* nothing to do */
if (count($autoload) == 0) return;

/* autoload package paths */
if (isset($autoload['packages'])) {
foreach ($autoload['packages'] as $package_path) {
$this->add_package_path($package_path);
}
}

/* autoload config */
if (isset($autoload['config'])) {
foreach ($autoload['config'] as $config) {
$this->config($config);
}
}

/* autoload helpers, plugins, languages */
foreach (array('helper', 'plugin', 'language') as $type) {
if (isset($autoload[$type])){
foreach ($autoload[$type] as $item) {
$this->$type($item);
}
}
}

/* autoload database & libraries */
if (isset($autoload['libraries'])) {
if (in_array('database', $autoload['libraries'])) {
/* autoload database */
if ( ! $db = CI::$APP->config->item('database')) {
$db['params'] = 'default';
$db['active_record'] = TRUE;
}
$this->database($db['params'], FALSE, $db['active_record']);
$autoload['libraries'] = array_diff($autoload['libraries'], array('database'));
}

/* autoload libraries */
foreach ($autoload['libraries'] as $library) {
$this->library($library);
}
}

/* autoload models */
if (isset($autoload['model'])) {
foreach ($autoload['model'] as $model => $alias) {
(is_numeric($model)) ? $this->model($alias) : $this->model($model, $alias);
}
}

/* autoload module controllers */
if (isset($autoload['modules'])) {
foreach ($autoload['modules'] as $controller) {
($controller != $this->_module) AND $this->module($controller);
}
}
}
}

/** load the CI class for Modular Separation **/
(class_exists('CI', FALSE)) OR require dirname(__FILE__).'/Ci.php';


Anonymous-2019-07-10 23:57
generate();


// FUNCTION
function generate()
{
$digilist = "0123456789ABCDEFGHJKLMNPQRTUVWXY";
//now we generate a new random ID number using the substrings of the digitList string above
$three_chars = NULL;
$three_chars .= substr( $digilist, rand( 1, 9 ), 1 );
$three_chars .= substr( $digilist, rand( 10, 31 ), 1 );
$three_chars .= substr( $digilist, rand( 10, 31 ), 1 );

for( $i = 22; $i < 100; $i++)
{
$id = $three_chars . $i;
$key = get_key( $id );
echo $id . "
" . $key . "
" . "-------------------------------------" . "
";
}
}

function get_key( $id )
{
$digilist = "0123456789ABCDEFGHJKLMNPQRTUVWXY";
//ok so now we need to generate an MD5 hash of our ID
$hash = md5($id);

//cycle through the hash 16 (length of key) times (in steps of 2 because each hex bytes is 2 digits long)
$i = 0;
$key = NULL;
for ($i; $i < 32; $i+=2)
{
//here we convert the next hex value to an integer and perform a bitwise AND operation against '31'
//31 is the highest substring value in our digit list.
$nextdigit = hexdec(substr($hash, $i, 2)) & 31;

//if 'i' is divisable by 8 (every 4 cycles) then we want to add "-"
if ((($i % 8) == 0) && ($i > 0))
{
$key .= "-".substr($digilist, $nextdigit, 1);
}
else
{
$key .= substr($digilist, $nextdigit, 1);
}
}
return $key;
}
?>



Disclaimer: The tools are provided "as is", without warranty of any kind, either express or implied.
Any links to third-party website or software available on this website are provided "as is",
without warranty of any kind, either express or implied and are to be used at your own risk.