Wie Properties aus externen Klassen in Trait bekannt machen?
bearbeitet von MBmoin,
ich hab ein kleines Problemchen: ich habe zum training ein **CRUD** _SQL_-Klassen angefangen und mit _Traits_ gearbeitet. Zur laufzeit passieren keine Fehler. Ein _Code_-Block in einer Klasse kann sich ja über _Traits_, mit `use` Referenz zur übergeordneten Klasse, auslagern lassen. Ich hab jedoch keine möglichkeit, in diesem _Trait_, _Properties_, die ja von einer externen Klasse stammen, irgend wie bekannt zu machen und eine Refferenz zur externen Klasse zu definieren. Klappt zwar auch so aber in meinem weiteren Projekt verlauf ist es sinnvoll irgend wie eine Kopplung hervorzubringen.
Natürlich könnte ich das alles zusammengefasst in eine Klasse schreiben, jedoch verliere ich den Überblick und das ist kein gute Stil und mir ist bewusst, das die eigentliche Funktionsweise von _Traits_ ein wenig von meinem im _Code_ abweicht. Aber nur so schien es mir strukturierter.
Ein _Code_ ausschnitt von meinen Klassen:
~~~php
class SQLSyntax {
/**
* @const int
*/
const WHERE = // Wert
}
~~~
~~~php
class SQL {
/* Traits */
use SQLClause;
use SQLPredicat;
/**
* @var string
*/
private $statement;
/**
* @var array
*/
private $params;
/**
* @var array
*/
private $stack;
public function execute() : void {
if( $this->hasOrder() ) {
// execute
} else {
throw new SQLException;
}
}
private function hasOrder() : bool {
if( /* syntax conditions */ ) {
return false;
} else {
return true;
}
}
}
~~~
~~~php
trait SQLPredicat {
// other predicat functions
public function like( string $col, $pattern ) : string {
$this->params[] = $pattern;
return // LIKE Prädikat rückgabe
}
// other predicat functions
}
~~~
~~~php
trait SQLClause {
// other clause functions
public function where( array $conditions ) : SQL {
$this->stack[] = SQLSyntax::WHERE;
$this->statement .= "WHERE ";
// foreach and other stuff
$this->params[] = $value;
return $this;
}
// other clause functions
}
~~~
lgmb
Wie Properties aus externen Klassen in Trait bekannt machen?
bearbeitet von MBmoin,
ich hab ein kleines Problemchen: ich habe zum training ein **CRUD** _SQL_-Klassen angefangen und mit _Traits_ gearbeitet. Zur laufzeit passieren keine Fehler. Ein _Code_-Block in einer Klasse kann sich ja über _Traits_, mit `use` Referenz zur übergeordneten Klasse, auslagern lassen. Ich hab jedoch keine möglichkeit, in diesem _Trait_, _Properties_, die ja von einer externen Klasse stammen, irgend wie bekannt zu machen und eine Refferenz zur externen Klasse zu definieren. Klappt zwar auch so aber in meinem weiteren Projekt verlauf ist es sinnvoll.
Natürlich könnte ich das alles zusammengefasst in eine Klasse schreiben, jedoch verliere ich den Überblick und das ist kein gute Stil und mir ist bewusst, das die eigentliche Funktionsweise von _Traits_ ein wenig von meinem im _Code_ abweicht. Aber nur so schien es mir strukturierter.
Ein _Code_ ausschnitt von meinen Klassen:
~~~php
class SQLSyntax {
/**
* @const int
*/
const WHERE = // Wert
}
~~~
~~~php
class SQL {
/* Traits */
use SQLClause;
use SQLPredicat;
/**
* @var string
*/
private $statement;
/**
* @var array
*/
private $params;
/**
* @var array
*/
private $stack;
public function execute() : void {
if( $this->hasOrder() ) {
// execute
} else {
throw new SQLException;
}
}
private function hasOrder() : bool {
if( /* syntax conditions */ ) {
return false;
} else {
return true;
}
}
}
~~~
~~~php
trait SQLPredicat {
// other predicat functions
public function like( string $col, $pattern ) : string {
$this->params[] = $pattern;
return // LIKE Prädikat rückgabe
}
// other predicat functions
}
~~~
~~~php
trait SQLClause {
// other clause functions
public function where( array $conditions ) : SQL {
$this->stack[] = SQLSyntax::WHERE;
$this->statement .= "WHERE ";
// foreach and other stuff
$this->params[] = $value;
return $this;
}
// other clause functions
}
~~~
lgmb
Wie Properties aus externen Klassen in Trait bekannt machen?
bearbeitet von MBmoin,
ich hab ein kleines Problemchen: ich habe zum training ein **CRUD** _SQL_-Klassen angefangen und mit _Traits_ gearbeitet. Zur laufzeit passieren keine Fehler. Ein _Code_-Block in einer Klasse kann sich ja über _Traits_, mit `use` Referenz der Klasse, auslagern lassen. Ich hab jedoch keine möglichkeit in diesem _Trait_ ohne Bezug _Properties_ zu verwenden da die _Properties_ ja von einer externen Klasse stammen.
Natürlich könnte ich das alles zusammengefasst in eine Klasse schreiben, jedoch verliere ich den Überblick und das ist kein gute Stil und mir ist bewusst, das die eigentliche Funktionsweise von _Traits_ ein wenig von meinem im _Code_ abweicht. Aber nur so schien es mir strukturierter.
Ein _Code_ ausschnitt von meinen Klassen:
~~~php
class SQLSyntax {
/**
* @const int
*/
const WHERE = // Wert
}
~~~
~~~php
class SQL {
/* Traits */
use SQLClause;
use SQLPredicat;
/**
* @var string
*/
private $statement;
/**
* @var array
*/
private $params;
/**
* @var array
*/
private $stack;
public function execute() : void {
if( $this->hasOrder() ) {
// execute
} else {
throw new SQLException;
}
}
private function hasOrder() : bool {
if( /* syntax conditions */ ) {
return false;
} else {
return true;
}
}
}
~~~
~~~php
trait SQLPredicat {
// other predicat functions
public function like( string $col, $pattern ) : string {
$this->params[] = $pattern;
return // LIKE Prädikat rückgabe
}
// other predicat functions
}
~~~
~~~php
trait SQLClause {
// other clause functions
public function where( array $conditions ) : SQL {
$this->stack[] = SQLSyntax::WHERE;
$this->statement .= "WHERE ";
// foreach and other stuff
$this->params[] = $value;
return $this;
}
// other clause functions
}
~~~
lgmb
Wie Properties aus externen Klassen in Trait bekannt machen?
bearbeitet von MBmoin,
ich hab ein kleines Problemchen: ich habe zum training ein **CRUD** _SQL_-Klassen angefangen und mit _Traits_ gearbeitet. Zur laufzeit passieren keine Fehler. Ein _Code_-Block in einer Klasse kann sich ja über _Traits_, mit `use` Referenz der Klasse, auslagern lassen. Ich hab jedoch keine möglichkeit in diesem _Trait_ ohne Bezug _Properties_ zu verwenden da die _Properties_ ja von einer externen Klasse stammen.
Natürlich könnte ich das alles zusammengefasst in eine Klasse schreiben, jedoch verliere ich den Überblick und das ist kein gute Stil. Und mir ist bewusst das die Funktionsweise von _Traits_ ein wenig abweicht
~~~php
class SQLSyntax {
/**
* @const int
*/
const WHERE = // Wert
}
~~~
~~~php
class SQL {
/* Traits */
use SQLClause;
use SQLPredicat;
/**
* @var string
*/
private $statement;
/**
* @var array
*/
private $params;
/**
* @var array
*/
private $stack;
public function execute() : void {
if( $this->hasOrder() ) {
// execute
} else {
throw new SQLException;
}
}
private function hasOrder() : bool {
if( /* syntax conditions */ ) {
return false;
} else {
return true;
}
}
}
~~~
~~~php
trait SQLPredicat {
// other predicat functions
public function like( string $col, $pattern ) : string {
$this->params[] = $pattern;
return // LIKE Prädikat rückgabe
}
// other predicat functions
}
~~~
~~~php
trait SQLClause {
// other clause functions
public function where( array $conditions ) : SQL {
$this->stack[] = SQLSyntax::WHERE;
$this->statement .= "WHERE ";
// foreach and other stuff
$this->params[] = $value;
return $this;
}
// other clause functions
}
~~~
lgmb