Intermediate OOP in PHP Video Lecture | PHP for beginners - Software Development

all right so again as as last time
I'm hoping there'll be a lot of
questions and then we can do a little
bit more exploration on certain topics
this one is a lot more code heavy as far
as showing code on the on the slide deck
if you don't understand a certain part
please ask and I'd be happy to explain
it if I don't get questions I'm assuming
everybody's following along and
understands everything which is probably
not always the case please do us so the
topics that we're going to cover in here
are pH Pease magic methods we're going
to go over polymorphism collections and
filtering of collections and then we're
going to touch on a couple of different
SPL concepts the iterator count and
array access we'll look at the listener
pattern and then we'll have a discussion
altogether about MVC and what different
people think MVC is or how it should be
implemented and then I've got a brief
couple of words on loose coupling and
high cohesion which are low concepts
that you should strive for I will post
it or I believe it's it's a Google thing
I think I can embed it so I'll stick it
on the site as long as that's the case
if not I'll try and figure out a way
that I can get it out of Google and put
it on somewhere to PDF I'm hoping I can
just embed it and then that would be
great so you can okay so it'll embed it
there I don't know if you guys have been
to the site for a while from range PHP
org it's totally different now it's
instead of a 207 on page Joomla site
with lots of Viagra and Cialis ads it is
now a three page straight-up HTML site
and so we now have a presentation posted
from three years ago and I'm planning on
adding more as I find them and convert
them more work with them so magic
methods yes
no it won't be the first presentation on
YouTube but it should be one of the
quickest from time it was done to time
on YouTube because we've now got this
thanks to Chad so we should have good
audio and video for this we've had good
video on on many of the past
presentations but our audio has been
horrible so with that being said magic
methods so if you've done
object-oriented programming and you've
done a constructor you've dealt with the
magic method now PHP provides a bunch of
other ones I think
14:15 if you count autoload and they're
all invoked at certain different times
and I'll briefly go over when they're
invoked and then we'll move on to the
next topic
so construct is going to be invoked
whenever you call new on a class it's
the thing that's going to set up and
initialize the values of your object
destruct is the opposite of that it's
going to be run when the object is about
to go out of scope or get deleted and
garbage collected so you can do things
like shut down database connections or
spit out an error log or a log message
or whatever you want magic call is going
to be called whenever you try and make a
method call to something that you don't
have access to now this could be for a
number of reasons and and many of these
next ones are this very similar
explanation it's in the scope that
you're not in is when they'll be called
so what I mean by that is when you call
a method and it either doesn't exist or
you don't have access to it the magic
call method is going to be called so in
other words if you're in a scope where
you're outside of an object and you try
and call a protected method and you have
an underscore underscore called method
underscore underscore call is going to
be called it's also going to be called
if you don't have that method at all
okay so if you call a method from within
the class and it doesn't exist it will
be called but if you call a method that
does exist from within the class magic
call will not get called does that make
sense so again like I said the rest of
these up till unset all get called when
you're outside of the scope of whatever
it is you're trying to do
so call static is the same sort of deal
but it's going to work on static methods
so if you try and make a call to a
static method that doesn't exist or you
don't have access to it call static will
get called get is going to work if you
try and get to a variable that you don't
have access to from in a read context if
you're trying to set the value to
another variable or something like that
then you're going to end up calling
magic set this make sense so far is set
and unset are the same kind of thing is
set will be called if you try and see if
a particular variable is set and you
don't have access to it on set same kind
of thing when you try and call unset on
a variable that you don't have access to
the next ones are a little bit different
sleep and wake up or paired together
they get called at the time when you're
about to serialize or unsee realize an
object which is converted into a string
format that you can do to store it in a
database or pass it over the wire or
something like that you can do things
like close down your database
connections or get rid of resources and
other things that can't be serialized in
there and then wake up is the other side
of that that's when you call uncie
realized an object it's going to call
wake up so it can re-establish those
connections or create the objects that
it needs to in order to be fully put
back together the invoke method is
pretty awesome what this one allows you
to do is you can actually create an
object and then call it like it's a
function so when I did you know dollar
bungalow equals new bungalow I can now
do dollar bungalow and parentheses and
it will call invoke and it can run
something so this can be pretty powerful
if you think of a function where you
would have to pass in a lot of
parameters in order to get it to work
you can actually make this into a class
and you can configure the class and do
all this stuff and then pass that class
around and allow that class to be called
as though it was a function but it still
has access to all of the class and
object things
it's it is the actual function that's
going to be called if you call a pet
object like it was a function and we can
come back and do an example of that
later on if you'd like set state I don't
see used very often at all but it's
going to be used if you're using of our
export where an exports a function in
PHP that will give you back a sort of
runnable code example of a particular
object so if you take that output of our
export and eval it or run it or save it
to a file and run it you should in
theory get back to that same state and
set state helps you do that the clone
method is something that gets called
when you call clone on an object so you
may have a counter or some things that
you want to keep track of how many
unique objects or put a serial number
that's unique on a particular object or
something like that
even if it's cloned this gives you that
opportunity to do that the other thing
that clone is very useful for is by
default clone does a what's called a
shallow copy so it'll get the primitives
like the scalar types integers and
strings and floats and so on and those
all are their own instance anyway but if
you had another object inside that class
that you're referring to it doesn't go
and clone that by default so if you tell
it in the clone method in the magic
clone method go ahead and clone this
object as well now your new cloned
object will have a new cloned object
that matches whatever it was that you
cloned before kind of a goofy
explanation but does that make sense all
right
and then autoload and I put that
separately because autoload is
technically not a magic method it's a
magic function but it allow it's and
there's better ways to do it than
underscore underscore autoload I would
recommend SPL register autoload if
you're looking at doing Auto loading but
what Auto loading is who's familiar with
Auto loading all right we're definitely
going over Auto loading at the end of
this because Auto loading is awesome
Auto loading allows you to at the moment
it needs it like let's say say Newhouse
and the code doesn't know about house I
can it will automatically call this auto
load function and I can figure out okay
the class name is house it's going to be
in this directory require that function
or that that class rather that file
where it exists just before I need it so
instead of having a bunch of requires
and includes at the top of my file I
don't need any of that I just put my
auto loader in place and now I just use
whatever class I need if I don't use it
I don't include it it never gets called
it's awesome so we'll go over that at
the end all right so polymorphism so
this is an example of polymorphism and I
mentioned back with the interfaces that
we were going to talk a little bit about
polymorphism so what I got here is I've
got three different classes that
implement the same interface they all
implement a speaking interface now
obviously cats and dogs and people speak
it differently but we can tell them all
to speak and according to this example
the speaking interface would have a
method on it called speak so I make a
new array called stuff and I pass in a
new dog and cat and a distinguished
gentleman and then I loop over them and
I tell them all to speak and I get meow
and woof and what what monocle and it's
all good because they implement those
interfaces and so I know that I'm going
to have that method there so
polymorphism is when it allows you to
use different objects in different
context without having to know
necessarily what kind of an object
you're dealing with does that make sense
okay all right so Dirk had asked for
some examples about how to deal with
collections of things and so the next
quite a few slides are dealing with
collections and in this case we're
dealing with silverware and I think
silverware works pretty well as far as
polymorphism and collections and things
go so let's assume I've got an interface
called silverware container and it's
going to have something like add utensil
and get utensil and they look pretty
much like this but you can imagine what
the code might be inside maybe I'm
storing it in an array or something like
that and I can pass in some item of
silverware and it will store it in that
collection right so my silverware
container I could have perhaps a
silverware drawer I could have that
little thing that goes in the dishwasher
I could have you know a backpack or a
sack or something like that these are
all valid silverware containers that I
need to be able to add utensils to so
here's again the silverware container
interface so all of the things that I'm
going to be considering silverware
containers would implement this
interface and then I would know for sure
that they would have these two methods
on them so I'd know I can add a utensil
to them and I can get a utensil from
them by passing in a particular filter
and then we'll go ahead and make an
interface for silverware as well so all
the silverware has got a couple of
different things that are in common it's
got it's going to know whether or not
it's clean and it's going to know what
type it is so we can you know use that
and be able to tell if we're trying to
saw through a steak with a spoon or
something like that all right so then
here's the abstract class so we've now
got common functionality that I can
implement as a utensil now you see a
utensil is implementing the silverware
interface so I've got my get type and is
clean and they're defined and I also
went ahead and built the default
constructor but I don't want just a
generic utensil it doesn't like here's
the utensil it doesn't make sense right
I want a fork or a nine
for a spoon or something like that so
this would be another example of where
you would make something abstract even
though I've provided all of the
functionality and you can extend this in
a way where you may not need to provide
any additional functionality but I don't
want you to just create a utensil is
what's a utensil I don't know it's a
thing but our concept does they really
understand this code before I go on to
the next slide all right so now we've
got an extension we've got a fork right
and I believe I meant to put use it on
the other utensil as well so let's
pretend I did that and when I use a fork
it does the stabby stab thing and once
it does that it's now dirty so it sets
the dirty flag to true which would mean
that when you ask it if it's clean it
would say no it's not clean so now we've
got a spoon and the same thing except
for use it just makes it dirty
immediately we don't have to do any
special Spoony sorts of things or we can
do it right and use it but we also
provide a lick clean function that makes
it go back to clean right so there's
different functionality it's provided
within each of these classes that's
different for each one right you're not
going to probably slice with a spoon and
you're not going to stab with it either
what's that probably not but you might
wipe it on your pants
so we've now provided a way to clean
that so basically we've got a fork that
once you use it it's going to be dirty
but we've got a way to clean our Forks
and and our spoons so there's so there's
our example of a couple of different
place settings or utensils so now we're
going to put the silver away so I'm
going to create a new fork and a new
knife and a you new spoon but before I
do that I'm going to use the spoon right
which makes it dirty but then I'm going
to go ahead and add it into the drawer
so now I've got a drawer and it's got a
fork and a knife and a dirty spoon it
might
so let's say we want to know how many
utensils are in the drawer right if
we're talking about a real drawer this
is kind of a pain it's dump it all out
and start counting but we've got
software for that so if we've got a
virtual object orientated drawer we can
do a number of things we can add a
method called get number of items and we
can go and say okay in that method we're
going to return count of whatever thing
we're storing our stuff in probably an
array or we can implement this SP
accountable and this is an interface
that's provided in the standard PHP
library that's what SPO stands for this
one's easy and it's pretty awesome so we
take our drawer and we tell it
implements countable and all we have to
do is provide a single method called
count and in there we're going to go
ahead and do the count this items and
what that allows us to do now is we can
actually run count on the drawer and it
will tell us how many things are in
there now if I hadn't done this what are
you supposed to be running count on the
drawer would give us right it would give
us one we have one drawer it's one
object right but by overwriting this and
making it implement countable now PHP
says hey I'm dealing with this object
that implements countable so now I can
run something inside of that object
because I know it's there because the
interface said it's going to be there
and it's going to tell us something
different so in this case we tell it how
many things are in the drawer this makes
sense
so the next thing maybe we want to
retrieve specific utensils now storing
utensils in an array or whatever doesn't
make a ton of sense right because you
know I don't necessarily know that
there's a fork at index 2 or a knife at
index 1 or whatever else but let's say
we want to do that so we could do this
and this is the obvious way of we're
gonna say get utensil at index we're
passing in an index and if it's set
we've got something there then we're
going to return it otherwise we'll
return false ok so simple enough right
or we can use another SPL interface
called array access so we tell our
drawer implements array access and array
access has four methods
we have to define it has offset get off
set set offset exists and off set unset
so these provide a way for us to deal
with the drawer as though it was an
array directly instead of calling a
method we can just use square brackets
at the end of our drawer object so these
are pretty simple ones we've got offset
exist is pretty much just doing a check
to see if the set if it's set so we
don't end up with notices or anything
like that
unset just done sets it off set get
checks to see if it's there and if it's
there it returns it otherwise we return
false so pretty much off set get is what
we had before with get it at the
particular index and then off set set
now this one's a little bit tricky in it
and when I was first learning this it
took me a little bit to figure out it'll
make a little bit more sense on the next
screen but I've got a little bit more
code here so first I'm checking to see
if the offset that we pass in is an OL
and if it is then I do the special
square bracket array append that really
where that one right here
yep we're just going to append the value
onto the end of the array and if we do
specify an offset then we're going to
put the thing at that offset so it could
mean that we're replacing a fork with a
knife or something with something else
or putting it off you know it's some
arbitrary value when we put that offset
in there so what this allows us to do
now is we can retrieve with that first
line so we've got utensil is drawer 2 so
whatever was at index 2 is now stored in
utensil as well we can also create a new
thing and just stick it in the drawer
just with the square brackets without
doing that array access we don't have
that ability we would have to make a
method like add utensil to drawer or
something like that any questions on
that
yes
called empty I think PHP 5/5 has
something with that PHP 5/5 now allows
you to do arbitrary expressions in empty
that's one of the new features what's
that yeah so you don't have to set
something to a variable and then
determine if it's if it's empty you can
actually just call empty on false or
empty on true or empty on count of
whatever empty em on whatever so I think
there would be a way that you'd be able
to do what you're looking to do with
empty with 5/5 but as far as with
anything before that I'm not aware of
any way to do that alright so now we
want to go and loop over or deal with
the utensils in the drawer so we can use
an iterator an iterator is an actual
concept in PHP it's a concept in
object-oriented programming that allows
us to loop over things in a specific
manner so there's a couple different
ways that we can do that we can
implement the iterator interface which
is another SPL provided interface if we
do that there's a bunch of different
bits that we have to implement I think
that's current and rewind and a few
others I didn't go down that path for
this presentation but if you look at the
php.net Doc's
you'll see there's there's quite a few
things that you implement for that or
you can extend one of these and there's
actually probably 20 or 30 different
iterators that are provided there's
things like directory iterators there's
all of these there's append iterators or
array iterators ray iterator makes it
very easy to iterate over arrays funny
enough there's caching ones there's
callback ones where you can pass in a
callback and deal with it that way
there's an infinite iterator which is
kind of neat too so you can go and say
set up a like an array of the days of
the week and then put it into an
infinite iterator and then tell it I
want 20 of these and it's going to give
you 20 days cycling Monday Tuesday
Wednesday Thursday and so on until you
get through 20 so it's pretty neat it
just loops back to the beginning and and
keeps on going so the easiest way to do
all of this is just extend array
so all that other stuff I had as far as
add utensil and and and all that I don't
have to write any of it if I just extend
a Rea iterator so when I do that I'm
allowed to do this so I create my new
drawer I add a fork to it I create a
dirty Fork I have the dirty fork to it I
create a new knife and a new spin and I
put those in the drawer as well all of
that for free just by extending the
array iterator and now I can loop over
the in my drawer just like it's a normal
array or a normal anything else and what
I implemented there is a two string very
similar to what I did with the bungalow
and the shack that describes it so it
goes and figures out is it dirty or
clean and what type is it and so this is
the output that I would get from the
last bit of code yes I can still yeah so
if I put in dollar key double arrow
value I get the key back just like I
normally would for for looping over an
array yep if I knew what index it was
sure or if I go and I say loop over this
and find the one where it's dirty and
then clean it or whatever
we'd have to implement a way to clean
Forks because right now we don't have
one but but yeah what's that we could do
that we could do that some companies do
that so now let's look at another
iterator so another way to loop over
this drawer so let's say I don't care
that I've got clean and dirty silverware
in the same drawer but I do want to only
get back clean ones coming you know
parents-in-law whatever coming over and
I don't want to put them dirty stuff on
that table
so I've implemented a filter and this
extends filter iterator which is another
another iterator that's provided by PHP
all of the rest of the stuff for
iterator has already been built
automatically I believe filter iterator
is an extension of array iterator so I
pass in an iterator
and I think that comes on the next slide
the important part of the filter greater
iterator is this accept function so I
get the inner iterator which is going to
be my drawer which is an iterator itself
and if it's a utensil then I check to
see if it's dirty if it or if it's not
dirty rather if it's not dirty I return
true for accept and if it is dirty I
return false so what this is essentially
going to do is when I'm iterating over
it it's gonna say I'm rejecting all of
the dirty stuff and only accepting the
clean stuff so even if I come across an
array and it's half dirty and half clean
only clean stuff is going to come out of
it so I can create the new filter pass
in the drawer is the iterator from the
inside and then loop over it and all I
get back out is the clean stuff the
dirty stuff was filtered out so that's
pretty neat and you can build any kind
of iterator that you want to that way
the filter ones are pretty cool you
could also go and take and build an
iterator that would say iterate and
filter over certain types and combine
those so I could make a fork iterator
and a clean iterator combine those
together and now I only get my clean
Forks out and all I have to do is loop
over that thing
all right I think I missed a slide when
I was doing this so that was all I had
on the filters and the iterators the
next bit is on the listener and observer
pattern so imagine we've got a class
here that's going to send some email and
I've only written parts of the class
obviously it's not all there but when we
want to send an email we're gonna pass
an email address and we're going to
validate it and if it's valid then we're
going to go ahead and send the email
right but I'm going to allow this thing
to be observable meaning that other
things can can jump in or do certain
things when when certain events happen
and in this case what I want to have
happen is I want to have it
something occur on on validate when I
call validate so when I implement SQL
subject here there's three functions
that I have to define or three methods I
have to define I've got an attachment a
detached method and a notify method if
I've got all those three implemented
I've implemented the implement
implemented the interface and all I'm
doing in here for attach is I'm just
adding a bunch of observers whoever
decides to attach to this email class to
an array or in this case it's going to
be an SPL object storage which is
another class that's provided by the SPL
and if they say detach I'm going to
detach it so observers here right yeah
there is is an SPL object storage which
allows me to differentiate one object
from another and be able to access it by
the object and say does this object
exist in you or erase a particular
object or what or whatever I want to do
so then I've got my notify function and
all I do on my notify function is like
loop over the observers that have
attached and because the observers back
here had to be SPL observer I know that
they have a certain method available and
that method is update so every single
thing I've attached has an update method
okay so really know about type hinting
they may not know about type engine
everybody knows and doesn't know
okay so type in ting is occurring here
when I'm putting this class or method or
not method class or interface before a
particular variable what it does is it
makes PHP enforce that whatever is
passed in must be of that type now it
could be an interface or it could be a
class it doesn't matter but it has to be
that right so in order for me to
actually attach an observer or detach an
observer that thing that I'm passing as
the observer that object has to
implement the SPL observer interface and
PHP enforces that you will get a fatal
error if you pass in something that is
not whatever I specified so I can type
int in PHP on objects on interfaces I
can also type int on arrays but as of
right now you can't type int on
primitives like scalar integer floats
and that sort of thing all right so now
we've looped over the observers we
update all of them which is basically
saying hey observers I just did
something that you're interested or
might be interested in so then we give
them a chance to go and do something so
what we can do there is we can say and
this is how it get called right so back
in the very beginning of this class we
had this email calls validate we do our
validation when we figure out if it's
odd or not and then we notify which then
loops over all over all of the observers
and tells them hey we did a thing you
should go look at it so here's here's an
example of one of the observers so we've
got an invalid email observer that
implements SPL observer which means it
has that update bit and again we've got
type hinting and it must be an SPL
subject and then we go and we in and
what comes in there when we notify it or
when we did the update rather we pass in
this object the one that we're actually
in so the observer is now going to have
a copy of the object or rather a
reference to that object in itself so it
can do things we go in the wrong way so
it can do things with that object
so in this case we check and we say okay
was the email valid or was it not valid
then don't send we're going to tell the
class don't send to invalid emails so we
don't have to have any code inside that
says well if it's this or that then
don't send or do send or whatever else
we can implement all of that in an
observer pattern have it completely
decoupled basically unrelated mostly
from the class that we're doing and
enhance the capabilities of our email
class without having to mess with the
email class so in this case if it
determines that the email validation
failed it's going to tell it hey don't
send this email so falling through in
the senton thing we would presumably go
and say hey are we enabled to send or
not enabled and if we're not don't send
go on to the next one we can also do
another one so how many people have sent
email in their PHP application and how
many people have done a situation where
you may be sending a lot of email or you
may be sending email to customers or
maybe you've got test data in your non
production database that has real
customer emails in it right any and you
want to be sure that you're not actually
sending real emails to real customers
when you're just testing right so
there's all sorts of different ways
around this you can go and make it so
the mail server can only send to certain
domains so you can get only your test
stuff you can make it so that it
automatically changes the email address
to your own or your Gmail or something
that you can get but then you've got
this path in your code that is different
for each time you you know for each each
environment that you're running this
code in so this way if I attach a
limited domain observer right now
imagine that I can configure this and I
can say here's the domains that are
allowed to be sent to and I can put that
in that object and then I attach that
object as a listener to my email the
code now says okay the emails valid
everybody that wants to do something
before I get a chance to send go do it
now so in this case we go and okay if
it's a valid email now we're going to go
and check the domain on that email and
if that domain is in our list of
allowable domains we'll
to go through otherwise we're going to
disable the sending ability and we've
done that outside of our class outside
of our email but we've given it
functionality in a different way that
makes sense so here's how you use this
thing we're gonna create our email
object we're gonna create our email
invalid email observer and our limited
domain observer and then we attach them
to the email ER and then we tell the
email send its email right if you
remember in the beginning that shut up
okay it sounds way different all right
so we send our email it checks to see if
it's valid remember validate goes
doesn't send new shirts
it is alright so notify goes out to all
these observers so it's going to send a
message out to invalid email it's going
to call update invalid emails going to
get a chance to say if this isn't a
valid email address at all then don't
send and then we're going to go in and
do limited domain observer and see is
bar comm a domain that we're allowed to
send to and if it's not then we're going
to disable sending and then it would
continue on with its flow and continue
to send the email I think low battery
it's just on low battery is on yeah
we're nearly done it might make it any
questions on an observer pattern or
listener pattern it's super powerful and
super cool all the things that you can
do with it without having to mess with
your main code if you just give it this
ability to tell say hey I'm interested
in something you're doing give me a
chance to do something about it then you
can redirect the flow of your program
without having to mess with or have your
email class or your whatever class know
about these these other things so you
don't have like you don't have to
implement those those are it's a way to
do it
that's that SPL provides SPL observer an
SPL subject or ways that it provides but
you can you can implement this pattern
even without those in this case they
implement a spiels subject so these are
the things that you want to that you
want to be able to observe and then the
observer is this one the thing that
wants to do something about the thing
that it's observing again you can
implement this in your own way you could
have it so it passes a particular
message and then your thing can deal
with particular messages that it does or
doesn't want to deal with this one
doesn't provide that it just says okay
pass the whole class back or pass this
object off to the update method in some
ways I found it a little bit limiting
and what you can do by using SPL
observer or SPL subject but the pattern
is solid the patterns really good
all right so the next concept I wanted
to talk about a little bit is loose
coupling and this is the idea of
minimizing those dependencies minimizing
the the number of classes that you have
to deal with it once so in the in the
last example with the email and the
observers the coupling between those was
minimal right the observers knew about
the email class because they had to deal
with it the email class has no idea
about all of the different observers we
could write right we could write any
number of observers and not have to
change our email class at all so we've
instead of having the email class go out
and say okay we need to deal with
invalid emails we need to deal with if
the domain is wrong we need to deal with
if it doesn't have an @ sign we need to
deal with this is that if our mail
servers down we can attach all of those
things as observers those things know
about the email class email class
doesn't have to know anything about them
because we follow that interface and we
have loose coupling which makes it
easier for us to test it makes this
easier it makes it easier for us to
write code and it generally makes for
cleaner code that leads into a concept
called inversion of control or
dependency injection inversion of
control is where say you again we're
building an email class and you had a
validator class that you wanted to put
inside of it rather than having the
email class build that validator class
and configure it and do all the things
and then use it we build the validator
class or classes somewhere else and pass
it into the email class in order for it
to in order for it to use it right that
gives us a lot more power because if
we're passing it in we can build all
sorts of things and pass those in right
so that's an inversion of control
instead of it finding the things that it
needs you give it the things that it
needs and then you've got a lot more
power and a lot more control over what
you want to do does that make sense cool
another concept it's important one is
high cohesion in classes and in methods
and in functions you want to do one
thing and do it well if you've got a
method or a class or sorry a method or a
function name and you've got the word
and in it like do this thing and this
you're probably doing something wrong
and it probably needs to be split into
more than one function so there's a
Wikipedia's got a decent article on
cohesion i'd recommend taking a look at
it i think there's seven different kinds
of cohesion ranging all the way from
coincidental cohesion which is hey this
crap happens to be in the same file so
it's cohesive right all the way up to
functional cohesion which is everything
about these things is meant to do this
one it's it's for this one purpose and
there's a couple of different levels of
that throughout including communication
cohesion so they can talk to each other
or they're related based on what they're
doing or related based on the order of
how you're going to call things by
having a class with low coupling or
loose coupling and high cohesion you
were making it so it's easier for you to
build classes that are more powerful and
they can be recombined and rebuilt and
reused in different ways this is a
concept prefer composition over
inheritance so we know it in classes in
object oriented or we can extend a class
and make another one that gets all the
functionality or most of the
functionality of its parent class and
some of the properties and so on and
that's one way that you can extend the
functionality of a class but it's it's
probably not the best way so we could go
in again to our email class and we could
say okay we've got this email class and
it's very basic and it does this ballot
or it does this sending and then we say
oh man we're sending to a bunch of
invalid email addresses we really need
to make this thing check for validity
right well we could extend that and make
it a valid email sender and now it does
some functionality where it says okay
use the functionality in there but first
we've got a validate then we're going to
call this other thing and so on and then
all we need this other class or we need
this other functionality
so now we've got to extend our valid
email sender so that it can do domain
our valid domain limited email sender or
something like that right or we can go
and use composition which is building up
our functionality through composing it
of different classes of different
objects and we can have much more
powerful ways of getting done what we
need to do and a lot less problems that
you would get with inheritance so now is
time for discussion for NBC who is heard
of MVC about half who uses NBC who has
no idea at all what NBC is all right so
MVC is a pattern that is honestly not
entirely web happy but in the web it
allows us to organize things in a nice
happy way it was invented I believe in
the late 60s so it's not new at all but
it stands for model view controller and
it's a way to separate in the web at
least a way to separate where particular
functionality goes on our web page right
so I'm sure everybody's built pages
where you go and you have an open HTML
tag and you do some stuff and then you
open up the PHP tag and you loop and you
create a table and then you close the
PHP tag and you put some links in and
sometimes those links have some PHP
echoes in them and then you come down
and we make some includes and some
functions and in all this right and you
just read it top to bottom in it and it
all spits out something that hopefully
works sometimes right I've done it I'm
sure everybody else has it's pretty much
how you learn PHP to start with what you
may have noticed if you're doing that or
if you've moved a little bit beyond that
is if you want to change how something
looks that becomes a pain right if I
need to go and say okay all I need to do
is add one more column to this table
that I'm looping over with a for each
and it needs to be here okay I think
it's on this line we put another echo in
we go and run it and now I missed a
close TR tag and now my table rows I'll
shift it over and everything looks like
stair-step or whatever right
so NBC allows us to separate what the
responsibility is of different things so
our view in NBC is responsible for what
we're going to display typically it's
going to be HTML it might be something
like JSON or XML but it's going to be
the actual output or display of whatever
it is we're trying to do right our model
on the other hand is going to be a
business object a thing that we can deal
with it could be a user it could be a
contract or an order or something like
that and it should have the logic the
things about whatever it is that it is
right it's a domain object and then our
controller is where our request is going
to come in and we're going to handle
that request we're gonna say okay I see
you're coming in you're asking for this
particular bit of functionality you've
passed in this parameter in this
parameter in this parameter we're gonna
make sure those are valid and then we're
gonna go do something with a model and
then we're gonna go maybe write it to a
database or whatever so it allows us to
put those things in separate areas so
now our views look like HTML they're
very simple to deal with because they're
just output and our models are just
business logic they don't have to worry
about how they're going to be displayed
they just worry about doing business
logic e things right and then our
controller is what ties those together
and brings together the model and the
view and puts them together and says ok
you get this information it goes on the
view the view worries about rendering it
and handling the output of that now
who's who kind of follows the model is a
database where model should be the
database kind of method of thinking it's
very very common it's especially common
in like Ruby on Rails and this is okay
here's my model it expends class that
does some database stuff right I think
that's kind of harmful and the reason
for that is this so let's say we go down
the path of we're dealing with a user
right and our user has user things it's
got a username it's got a display name
so we can say hey welcome thanks for
signing in Jim Bob or whatever right and
we put that all together but it also has
to save to the database
right so it's now responsible for saving
of the database and we can go and say
hey user go load yourself from the
database and it loads and everything's
fine and it seems like there's no
problem what happens if what happens if
we want to maybe allow a different way
to log in right Facebook log in is
pretty popular github Twitter there's
ooofff there's a bunch of different ways
to log in none of those other ways has
anything at all to do with the database
right at least as far as we're concerned
we don't have access to Facebook's
database or github database or any of
these other things we have access to
their API so we have access to their
their so calls or their rest calls or
whatever it may be and so we can go and
use those right but if we've gone down
the path of user model means database
well now we've got to write a bunch of
other methods in our user model that
deal with other things right so we go
and make some more functions of connect
through Facebook or connect or github or
connect through this right and our class
starts getting bloated and bigger and
bigger and bigger right and every time
we want to add a new way to log in we
have to go and bloat it some more well
if we take that out and we separate
those two things and we say okay the
model for the user is just the things
about the user the user doesn't care how
it authenticates it doesn't care how we
persist the data it doesn't care how we
save it it could be to a file it could
be to a database it could be at a web
service it doesn't care it doesn't know
it doesn't need to know then we can
write it adapters that we'll read in
from a database and populate a user
model or read in from Facebook and
populate a user model or read in
whatever it is that we need to use maybe
it's not even been invented yet but we
just write that little class and now all
this our user model still works we
haven't changed it all of our code that
uses user model still works all we've
got to do is make another little
connection of this adapter talks to the
model and populates it and does the
things that it needs to do so anyway
that's why I think the model is the
database is harmful is because it limits
the way that we think and it limits the
way that we have to design our code any
questions on NBC is hoping this would be
a little more discussion e I guess
all right questions also I have another
joint in thing so again if you could
rate this one as well I would very much
appreciate it any questions on anything
we've covered tonight they will be
they'll be on Front Range PHP org in the
presentation section as I added plain
old HTML page all right no questions
yeah
five three implements everything I've
talked about yep but that being said
five five was released today which means
five three has one year left of life
before they discontinued any support for
it so if you can get on five for later I
would recommend it but five three is
totally fine right now okay