Witam, pisząc własny skrypt szkolę się z używania namespace i use, ale dostaje błędy że nie można znaleźć pliku... nie wiem jak z tego korzystać, czy mógłby ktoś to w prosty sposób opisać?

mam folder global i posiadam tam wszystkie klasy i kontrolery, ale nie wiem jak w global.php który nie jest klasą zaincludować te pliki przy użyciu use.. w root jaki powinien być namespace ? nie rozumiem tego... mam wielkie braki w programowaniu, które próbuje nadrobić, ale mi nie wychodzi

Najszybciej i najprościej jest wykorzystać composer i autoloader: https://thewebtier.com/php/psr4-autoloading...using-composer/
a jeśli chcesz to PHPowo zrobić, to musisz trzymać się PSR4: https://github.com/php-fig/fig-standards/bl...der-examples.md

a jakie są zalety zastosowania tego, bo w ogóle nie orientuje się w temacie... Tymczasowo próbuję tworzyć modele... tak samo nie potrafię zrozumieć czym się różni implementacja od expandsa oraz co dają abstrakcje w klasach... Mam duże braki w programowaniu i to jest smutne

Ogólnie namespace'y dają mocne uproszczenie i ułożenie struktury plików i logiki w projekcie. Dużo wygodniej się tworzy projekt używając namespace i use niż zabawy z include (każdy wie czym to się zazwyczaj kończyło )
Jeśli chcesz nauczyć się podstaw używania takich rzeczy, to najlepiej zacząć sobie jakiś kurs PHP z frameworkiem typu symfony czy laravel (ważne żeby był nowy i trzymal się PSR), nie ma co się smucić brakami, po to powstało tyle kursów programowania żeby można było się wszystkiego nauczyć  każdy z nas tu zaczynał więc każdy wie jak to jest nie rozumieć 3/4 rzeczy które po pewnym czasie stawały się banalne.

http://www.php.pl/Wortal/Artykuly/PHP/Pods...poczatkujacych5
http://www.php.pl/Wortal/Artykuly/PHP/Pods...-poczatkujacych
http://www.php.pl/Wortal/Artykuly/PHP/Pods...zestrzenie-nazw

Może nie są to jakieś świeże artykuły ale może nieco wyjaśnią koncepcje.

Dobrze, to powiem inaczej

mam plik a i w nim

[PHP] pobierz, plaintext 
class A {
   public $mysql
   function __construct() {
      $this->mysql = Połaczenie z baza danych;
      $b = new B();  
   }
}
[PHP] pobierz, plaintext 

oraz klase B gdzie potrzebuje uzyc połączenia z mysql z klasy A ale jeżęli próbuje dodać klase b do klasy a to nie widzi połączenia.. nie wiem czy implementować klasę czy co z nią zrobić... nie rozumiem tego

nie rozumiem jak to połączyć funkcja jednej jest potrzebna w konstrukcji drugiej i tak samo jest na odwrót ?

Jeśli chodzi o bazy to chyba singleton najczęściej jest używany, tutaj jakiś przykład: https://phpenthusiast.com/blog/the-singleto...-pattern-in-php.

Konkretny kod wrzucaj tutaj: https://onecompiler.com/php - będzie łatwiej bo kurde nie ogarniam tego ostatniego przykładu... może wystarczy w klasie B wstrzyknąć właśnie to połączenie mysql? (__construct($mysql)) - brakuje tutaj typowania

już tłumaczę o co mi chodzi. Mam klasę Engine gdzie jest wszystko ładowane między innymi połączenie z bazą danych oraz mam klasę Configuration która pobiera konfiguracje:

[PHP] pobierz, plaintext 
<?php
 
class Configuration
{
    /** @var id */
    public $id;
 
    /** @var key */
    public $key;
 
    /** @var value */
    public $value;
 
    /** @var array  */
    public $configuration = array();
 
    /** Constructor */
    public function __construct($key = null) {
        global $engine;
        if ($key == null) {
 
            $array = $engine->mysql->get($engine->prefix."config");
 
            foreach ($array as $data) {
                $this->configuration[$data["name"]] = $data["value"];
            }
 
            return $this->configuration;
        } else {
            return $this->getValueByKey($key);
        }
 
    }
 
    /**
     * @param id $id
     */
    public function setId(id $id): void
    {
        $this->id = $id;
    }
 
    /**
     * @return id
     */
    public function getId(): id
    {
        return $this->id;
    }
 
    /**
     * @return key
     */
    public function getKey(): key
    {
        return $this->key;
    }
 
    /**
     * @param key $key
     */
    public function setKey(key $key): void
    {
        $this->key = $key;
    }
 
    /**
     * @return value
     */
    public function getValue(): value
    {
        return $this->value;
    }
 
    /**
     * @param value $value
     */
    public function setValue(value $value): void
    {
        $this->value = $value;
    }
 
    public function save() {
        global $engine;
 
        $data = array("name" => $this->key,
            "value" => $this->value);
        if ($this->getValueByKey($this->key)) {
            $engine->mysql->where("name", $this->key);
            $id = $engine->mysql->update($engine->prefix."config", $data);
        } else {
 
            $id = $engine->mysql->insert($engine->prefix."config", $data);
        }
 
        if (isset($id) && $id > 0)
            return true;
        else
            return false;
    }
 
    /**
     * @param key $key
     */
    public function getValueByKey($key)
    {
        global $engine;
 
        $engine->mysql->where("name", $key);
        $ret = $engine->mysql->getOne($engine->prefix."config");
 
        $this->id = $ret["id"];
        $this->key = $ret["name"];
        $this->value = $ret["value"];
        if (isset($this->id) && $this->id > 0)
            return true;
        else
            return false;
    }
}
[PHP] pobierz, plaintext 

Potrzebuje pobrać konfigurację z bazy danych w konstrukcji Engine, ale bez konstrukcji Engine klasa Configuration nie ma danych o mysql bo znajduje się ona w Engine i teraz nie wiem jak to ze sobą połączyć... czy jest nawet taka możliwość

Cześć,

powiedz czym jest Engine - jest to silnik bazy danych czy taki Core systemu?
Rozumiem, że klasa Configuration to obsługa jakieś tabeli bazy danych niż config systemowy?

Jeśli chcesz mieć dostęp z każdego miejsca do konfiguracji to dodajesz do klasy Engine set/getConfiguration i po prostu wrzucasz to gdzieś w kernelu lub robisz jakiś singleton który będzie miał dostęp zawartości w każdym miejscu.
Jak lepiej to opiszesz to zrobię jakiś przykładowy kod

Możesz także wykorzystać Dependancy Injection - https://designpatternsphp.readthedocs.io/pl...ion/README.html - akurat przykład powiązany mniej więcej z tym co chcesz zrobić

+ https://php-di.org/doc/getting-started.html - po przejrzeniu tego wydaje mi się że załapiesz o co chodzi,

i jeszcze jedno: https://symfonycasts.com/screencast/depende...injection/intro


Tyle że jak widzisz, wymaga to poznania autoloadera + composera o których pisałem wyżej

Engine to klasa silnika która zawiera połączenie z bazą danych, system szablonów i takie tam elementy.
Klasa Configuration to obsługa konfigu z bazy danych... tak się składa że w pliku config mam tylko połączenie z bazą danych, a reszta jest pobierana z niej w momencie połączenia... Problem polegał na tym ze w Engine trzeba było załadować konfigurację, a w konfiguracji silnik do połączenia się z bazą danych skomplikowałem to, wiem... Rozwiązaniem było danie parametru this jako engine podczas includowania konfiguracji :

przykład

[PHP] pobierz, plaintext 
$configuration = new Configuration($this);
[PHP] pobierz, plaintext 

i zrezygnować z global $engine

Pierwszy wpis zawiera błędną tezę, że przestrzenie nazw i autoloading to to samo. To są odrębne mechanizmy.