web-dev-qa-db-fra.com

PHP: Erreur fatale: appel d'une fonction membre sur un non-objet

Obtenir une erreur très étrange ici, j'écris une classe de base de données flatfile et tout cela fonctionnait bien jusqu'à ce que je rafraîchi et maintenant je reçois constamment ce message:

Erreur fatale : Appel à un nom de fonction membre () sur un non-objet dans /home/reithg/public_html/test/engine/class.database.php on line 50

J'appelle la classe comme suit:

<?php
ini_set('display_errors', '1');

require('engine/class.database.php');

$config = new Config("lessons", array('first', 'second', 'third', 'fourth'), "data/");
$db = new Database($config, true);

print("Querying DB for 'theta' no exclusions: <br />");
print_r($db->query('theta', NULL, NULL));

print("<p /> Querying DB for 'theta' in column 'second': <br />");
print_r($db->query('theta', 'second', NULL));

print("<p /> Querying DB for first two rows: <br />");
print_r($db->getRows(2));

print("<p /> Querying DB for last three rows: <br />");
print_r($db->getRows(3, true));

print("<p /> Cleaning data for safe DB input: <br />");
$testInput = array('escape|these||delimiters','and\these\\slashes','and\0these\0nulls',"don't, forget quotes");
print("input: ");
print_r($testInput);
echo("<br />output: ");
print($db->addRow($testInput));
?>

Voici mon class.database.php 

<?php
require('class.config.php');
require('class.column.php');

    class Database {
        private
            $_config,
            $_pointer;

        public function __construct(Config $config)  {
            $this->_config = $config;
            return true;
        }

        private function connect($method) {
            if (!($this->_pointer = @fopen($this->_config->db(), $method)))
            echo("Unable to connect to database");
        }

        private function disconnect() {
            fclose($this->_pointer);
        }

        private function lock($method) {
            if(flock($this->_pointer, $method))
                return true;
            return false;
        }

        private function unlock() {
            flock($this->_pointer, LOCK_UN);
        }

        private function cleanInput($input) {   
            $data = array_map(array($this, 'escapeData'), $input);
            $output = implode($this->_config->delimiter(), $data)."\r\n";
            return $output;
        }

        private function escapeData($data) 
        {
            $search = array('\\', '"', "'", '\\0', '\n', $this->_config->delimiter());
            $replace = array('\\\\', '\"', "\'", '\\0', '\\n', '\\'.$this->_config->delimiter());
            $output = str_replace(array_unique($search), array_unique($replace), $data);
            return $output;
        }

        private function formatRow($data) {
            foreach($data as $key => $value) {
                $row[$this->_config->columns($key, "position")->name()] = $value;
            }
            return $row;
        }

        public function dumpToArray() {
            $arrayDump;
            foreach(file($this->_config->db(), FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) as $row => $content)
                $arrayDump[$row] = formatRow(explode($this->_config->delimiter(),$content));
            return $arrayDump;
        }

        public function addRow(array $data) {
            $this->connect('ab');
            if($this->lock(LOCK_EX)) {
                // fwrite($this->_pointer, $this->cleanInput($data));
                echo($this->cleanInput($data));
                $this->unlock();
                $this->disconnect();
                return true;
            } else {
                $this->disconnect();
                return false;
            }
        }

        public function query($value, $column = NULL, $limit = NULL) {
            $this->connect('rb');
            $results = array();
            while ((is_null($limit) || (count($results) < $limit)) && !feof($this->_pointer)) {
                $data = explode($this->_config->delimiter(), fgets($this->_pointer, 1024));
                if(!is_null($column)) {
                    if ($data[$this->_config->columns($column, "string")->index()] == $value)
                        array_Push($results, $this->formatRow($data));
                } else {
                    if (in_array($value, $data))
                        array_Push($results, $this->formatRow($data));
                }
            }
            $this->disconnect();
            switch (count($results)) {
                case 0;
                    return false;
                case 1;
                    return $results[0];
                default;
                    return $results;
            }
        }

        public function getRows($limit = 1, $reverse = false) {
            $this->connect('rb');
            $offset = 0;
            $results = array();
            if ($reverse) {
                while(count($results) < $limit && fseek($this->_pointer, $offset, SEEK_END) >= 0) {
                    $char = fgetc($this->_pointer);
                    if($char == "\n" || $char == "\r"){
                        $offset --;
                        $data = explode($this->_config->delimiter(), fgets($this->_pointer, 1024));
                        array_Push($results, $this->formatRow($data));
                    }
                    $offset--;
                }
                $results = array_reverse($results);
            } else {
                while ((($limit === NULL) || (count($results) < $limit)) && !feof($this->_pointer)) {
                    $data = explode($this->_config->delimiter(), fgets($this->_pointer, 1024));
                    array_Push($results, $this->formatRow($data));
                }
            }
            $this->disconnect();
            return $results;
        }
    }
?>

class.config.php 

<?php
    class Config {
        private
            $_db,
            $_file,
            $_columns = array(),
            $_directory,
            $_delimiter;

        public function __construct($file, array $columns, $directory = NULL, $delimiter = "|")  {
            $this->_db = $directory.$file.".db";
            $this->defineColumns($columns);
            $this->_directory = $directory;
            $this->_delimiter = $delimiter;
        } 

        public function db() {
            return $this->_db;
        }

        public function delimiter() {
            return $this->_delimiter;
        }       

        private function defineColumns($constants) {
            for ($i=0;$i<count($constants);$i++) {
                if(in_array($constants[$i], $this->_columns))
                    die("Column names must be unique");
                $column = new Column($constants[$i], $i);
                $this->_columns[$column->name()] = $column;
            }
        }

        public function columns($index, $search = "string") {
            switch ($search) {
                case "string";
                    return $this->_columns[$index];
                    break;
                case "position";
                    $keys = array_keys($this->_columns);
                    return $this->_columns[$keys[$index]];
                    break;
                default;
                    return false;
            }   
        }
    }
?>

class.column.php 

<?php
    class Column { 
        const
            ALL = "0",
            STRING = "1",
            NUMBER = "2",
            INT = "3",
            AUTO_INCREMENT = "4",
            CURRENT_TIME = "5";

        private
            $_type = ALL,
            $_name,
            $_index,
            $_maxChars = "256";

        public function __construct($name, $index, $type = NULL, $maxChars = NULL)  {
            $this->_name = $name;
            $this->_index = $index;
            if(!is_null($type))
                setDataType($type);
            if(!is_null($maxChars))
                setMaxChars($maxChars);
            return $this;
        }

        public function setDataType($type) {
            switch ($type) {
                case ALL;
                case STRING;
                case NUMBER;
                case INT;
                case AUTO_INCREMENT;
                case CURRENT_TIME;
                    $this->_type = $type;
                    break;
                default;
                    return false;
            }
        }

        public function auditData($data) {
            switch ($this->_type) {
                case ALL;
                    $output = $data;
                    break;
                case STRING;
                    $output = (string) $data;
                    break;
                case NUMBER;
                    $output = (float) $data;
                    break;
                case INT;
                    $output = (int) $data;
                    break;
                case AUTO_INCREMENT;
                    $output = (int) $data;
                    break;
                case CURRENT_TIME;
                    $output = time();
                    break;
                default;
                    return false;
            }
            return $output;
        }

        public function setMaxChars($maxChars) {
            if(is_int($maxChars)) {
                $this->_maxChars = $maxChars;
            }
        }

        public function name() {
            return $this->_name;
        }

        public function index() {
            return $this->_index;
        }
    }
?>

Je sais que c'est beaucoup de code, mais je ne peux pas comprendre pourquoi cela se produit soudainement, littéralement en une actualisation sans aucune modification du code. Même si je reviens sur des versions antérieures qui fonctionnaient aussi, cela se produit.

Quand j'essaye de faire:

print($this->_config->columns($key, "position"));

Il retourne:

Erreur fatale capturable: Objet de la classe La colonne n'a pas pu être convertie En chaîne dans /home/reithg/public_html/test/engine/class.database.php * à la ligne 50 *

Ce qui montre que je suis en train d'exécuter name() sur un membre de la classe Column qui a une méthode publique appelée name()

Quand je fais:

print($this->_config->columns($key, "position")->name());

il retourne (un mot par heure comme il est dans une boucle foreach);

premier deuxième troisième quatrième premier troisième deuxième troisième quatrième

Donc, il est clair que nous travaillons 1 ligne avant.

phpfatal-error
8
George Reith

La réponse était due aux caractères cachés situés dans le fichier lessons.db . 

L’erreur montrée n’a rien à voir avec cela et je voudrais remercier toutes les personnes qui ont pris le temps de donner leurs deux sous.

7
George Reith

J'ai deux choses pour vous:

  1. Quand vous dites: "Je sais que c'est beaucoup de code, mais je ne comprends pas pourquoi cela se produit soudainement, littéralement en une actualisation sans aucune modification du code. Même si je retourne aux versions antérieures cela a également fonctionné cela se passe. " Je voudrais demander si vous programmez sur vous PHP code via un navigateur? Si tel est le cas, parfois le cache vous dérange, et je trouve qu'il est beaucoup plus facile de développer mes modèles PHP via l'interface de ligne de commande PHP. Si c'est le cas pas pour vous, pensez peut-être à désactiver complètement le cache de votre navigateur lors du développement.
  2. Je pense que le problème que vous rencontrez provient d'erreurs de syntaxe dans les colonnes de fonctions publiques de votre classe de configuration. Je pense que vous devez lire la syntaxe de switch-cases http://php.net/manual/en/control-structures.switch.php vous remarquerez que vous avez utilisé des points-virgules après les consignes, où vous auriez dû utiliser simplement les deux points. En outre, il n'y a pas besoin de casser; après votre retour, car votre code n'atteindra jamais ce point de toute façon ...

J'espère que cela aide - bonne chance ...

0
kraenhansen