PHP Classes - A Simple Sample Class
OK, so in the last two posts we covered the basic theory of objects. Now lets go ahead and make one.
To create an object in PHP we use the term "class" in the same way we would use "function".
So what can we make an object for? Well pretty much anything really. To keep it simple at the start we'll go through making an object that simply manipulates some text.
So lets make our object, I'm going to be calling it "myText"
<?php
class myText{
}
?>
class myText{
}
?>
There, that was easy enough. Note that unlike functions there are no parenthesis after the name of the class that you can pass variables into. We'll come back to that later on. Now we'll add the first method. The first thing we are going to need to do is get the text that we will be formatting, so lets create a method that will do that, this one I'll be calling "getText".
<?php
class myText{
public function getText($textIn){
}
}
?>
class myText{
public function getText($textIn){
}
}
?>
Hmmm....hang on, what are we going to be doing with this text after we get it? Well the idea is that we can search the text for occurences of the word that we choose once it's loaded into the object. So any method could need to access the text. Guess we had better stick in an object level variable - these are actualy called paramters, but for now I'm going to keep calling them variables - to keep the text in so that all the other methods will have access to it and then have the getText method send the text it gets out to this variable.
<?php
class myText{
public $text;
public function getText($textIn){
$this->text = $textIn;
}
}
?>
class myText{
public $text;
public function getText($textIn){
$this->text = $textIn;
}
}
?>
OK, so that's that done. See the use of $this->text ? when working anywhere inside a class $this is basically a short way of saying "This Class" or "This Object". the use of -> is saying which variable or method within the class or object to are referring to. Also note that the $ is dropped from any variables that come after the -> (but you still need to use the parenthesis at the end of function names). So $this->text=$textIn tells the method that it is going to take the contents of the $textIn variable and send them to class variable $text. You will also have by now (I hope) noticed the word public at the start of both the $text variable and the getText() function. These are here to explicitly define the scope of each of these.
Right, so we have a method of getting text into the object now. Let us now make a method that will do something to that text.
<?php
class myFormat(){
public $text;
public function getText($textIn){
$this->text = $textIn;
}
public function makeCaps(){
$this->text = strtoupper($this->text);
}
}
?>
class myFormat(){
public $text;
public function getText($textIn){
$this->text = $textIn;
}
public function makeCaps(){
$this->text = strtoupper($this->text);
}
}
?>
So now we have a method that will make all the text uppercase. Not exactly anything to write home about, but it at least lets us see how easy it is to address variables that are stored at the object level from within a method.
Let's blast on and add a couple more methods to play about with the text, we'll take a look at them once we're done adding them all.
<?php
class myText{
public $text;
public function getText($textIn){
$this->text = $textIn;
}
public function makeCaps(){
$this->text = strtoupper($this->text);
}
public function delimit(){
$delimitText = $this->text;
$delimitText = str_replace(".", "", $delimitText);
$delimitText = str_replace(",", "", $delimitText);
$delimitText = str_replace("\n", '|', $delimitText);
$delimitText = str_replace(' ', ',', $delimitText);
return $delimitText;
}
public function txtToArray(){
$txtForArray = $this->delimit();
$textArray = explode('|', $txtForArray);
for($i=0; $i<=count($textArray)-1; $i++){
$textValue = $textArray[$i];
$textBack = explode(',', $textValue);
$textArray[$i] = array_filter($textBack);
}
return $textArray;
}
public function findWord($word){
$haystack = $this->txtToArray();
for($i=0; $i<=count($haystack)-1; $i++){
$result = array_search($word, $haystack[$i]);
if($result != false){
$line = $i+1;
$wordNo = $result+1;
$return[] = "Line No $line, Word No $wordNo";
}
}
return $return;
}
}?>
class myText{
public $text;
public function getText($textIn){
$this->text = $textIn;
}
public function makeCaps(){
$this->text = strtoupper($this->text);
}
public function delimit(){
$delimitText = $this->text;
$delimitText = str_replace(".", "", $delimitText);
$delimitText = str_replace(",", "", $delimitText);
$delimitText = str_replace("\n", '|', $delimitText);
$delimitText = str_replace(' ', ',', $delimitText);
return $delimitText;
}
public function txtToArray(){
$txtForArray = $this->delimit();
$textArray = explode('|', $txtForArray);
for($i=0; $i<=count($textArray)-1; $i++){
$textValue = $textArray[$i];
$textBack = explode(',', $textValue);
$textArray[$i] = array_filter($textBack);
}
return $textArray;
}
public function findWord($word){
$haystack = $this->txtToArray();
for($i=0; $i<=count($haystack)-1; $i++){
$result = array_search($word, $haystack[$i]);
if($result != false){
$line = $i+1;
$wordNo = $result+1;
$return[] = "Line No $line, Word No $wordNo";
}
}
return $return;
}
}?>
OK, so that's a whole bunch of code that you may or may not fully understand. Suffice it to say we have just added some methods that take in a text string, strips all full stops and commas out of it, splits the text ito lines (using the linux/unix \n control character, if you want to work with windows controls change the str_replace("\n"... to str_replace("\n\r"... ) and words and then lets someone find a word in the text returning each location by line and then number of words along that line that the number is in. Look over the delimit() and txtToArray() methods and you will see that they are very similar to the normal functions you would write outside of a class/object. they take in values and return other values and you can even call one method from inside another.
So now that we have made our class it would be good to get some output from it. Lets drop down outside the closing } of the class and add the code to make the class do something.
...
}
$mySearch = new myText();
$mySearch -> getText("This is some sample Text\nUsed to test out our sample class.");
$searchResults = $mySearch->findWord("sample");
if(count($searchResults) >= 1){
echo "word \"sample\" found at the following locations:<br>";
}
foreach($searchResults as $result){
echo "$result <br>";
}
echo"<br>Within : <br>{$mySearch->text}";
?>
}
$mySearch = new myText();
$mySearch -> getText("This is some sample Text\nUsed to test out our sample class.");
$searchResults = $mySearch->findWord("sample");
if(count($searchResults) >= 1){
echo "word \"sample\" found at the following locations:<br>";
}
foreach($searchResults as $result){
echo "$result <br>";
}
echo"<br>Within : <br>{$mySearch->text}";
?>
Notice that there is still the parenthesis when you call a new class, even though we didn't use any to declare the class at the beginning? Remember how I said we would come back to that? well here we go.
Classes have special methods, one of the most important is the constructor. This lets the class gather everything it needs when it is created. Lets modify our class a little bit and add the following constructor method at the top :
<?php
class myText{
public $text;
public function __construct($text){
$this->getText($text);
}
public function getText($textIn){
....
class myText{
public $text;
public function __construct($text){
$this->getText($text);
}
public function getText($textIn){
....
OK, now we have a constructor in place, what this does is load the text into the object as it's created. This makes sense in the example here because the object depends on having sent into it for it to really do anything. now when we create the new object we add the text into the parenthesis there, and skip the line that calls the getText method altogether.
...
}
$mySearch = new myText("This is some sample Text\nUsed to test out our sample class.");
$searchResults = $mySearch->findWord("sample");
if(count($searchResults) >= 1){
echo "word \"sample\" found at the following locations:<br>";
}
foreach($searchResults as $result){
echo "$result <br>";
}
echo"<br>Within : <br>{$mySearch->text}";
?>
}
$mySearch = new myText("This is some sample Text\nUsed to test out our sample class.");
$searchResults = $mySearch->findWord("sample");
if(count($searchResults) >= 1){
echo "word \"sample\" found at the following locations:<br>";
}
foreach($searchResults as $result){
echo "$result <br>";
}
echo"<br>Within : <br>{$mySearch->text}";
?>
That's almost it for our first look at classes, just one more thing, the scope. So far we have made everything public, this is the best way to create a new object because it lets you access each of the methods and variables for debugging. Now we have finished it, we can change some of the scope. For methods and variables that you don't want anything outside the object to access you can set it to either protected or private. Private goes a step further and stops child objects and/or parent objects accessing the method/variable either. Again it's not something we'll be getting into here, but for the sake of an example, change the word public that is before the $text at the top of the class to protected and see what happens when you run the code again.
Not good, huh? It stops the code getting direct access to the variable inside the object, so lets change that back. Where protected would come in handy would be to use it for the delimit() and txtToArray() methods, this would stop anyone calling these methods directly and potentially using them out of context.
Anyways, that's it for this "beginner class" (pun intended). I suggest that, assuming I didn't confuse you too much, you look into patterns in PHP. These are guides to standard designs for creating your own objects.
