In this course, you'll explore the basic structure of a web application, and how a web browser interacts with a web server. You'll be introduced to the request/response cycle, including GET/POST/Redirect. You'll also gain an introductory understanding of Hypertext Markup Language (HTML), as well as the basic syntax and data structures of the PHP language, variables, logic, iteration, arrays, error handling, and superglobal variables, among other elements. An introduction to Cascading Style Sheets (CSS) will allow you to style markup for webpages. Lastly, you'll gain the skills and knowledge to install and use an integrated PHP/MySQL environment like XAMPP or MAMP.
PHP - Modularity
Loading...
Do curso por University of Michigan
Building Web Applications in PHP
943 classificações
University of Michigan
943 classificações
Curso 1 de 4 em Specialization Web Applications for Everybody
Na lição
PHP Functions
We look at unique aspects of functions in PHP.
Conheça os instrutores
Charles SeveranceProfessor
School of Information
So now we're going to talk about modularity in a different way.
So we've been talking about functions, which is a way for you to rewrite code and
use it over and over again.
Now we're going to talk about modularity from a perspective of files.
Everything we've talked about up to now is like one PHP file.
But you can have functionality that might be across multiple files that you want to
include over and over.
And so there is a capability, include and require.
include looks for a file and if it's there, it pulls it in and if it's not,
it's non-fatal.
Require pulls it in and if it's not there, it is fatal.
I tend to use require almost always.
And so, there are things that you're going to require like that actually
are navigation stuff.
But then there's kind of library code, where you might be actually in multiple
files you want to require some functions that are not actually markup.
And you want to do that over and over again.
There's this thing called require_once, which is really cool.
because you can be requiring a file that requires a file that requires this file
that requires use utility code.
And then require a different file that requires the same utility code.
And as long as it's the same thing, it says, you know what,
I've already got that.
I don't have to do it.
Otherwise, you'd have to put all this if code in and we were doing that.
So require_once is something PHP gives to you that says,
no matter how many things we go and how many times we ask for this file,
once it's been required, we're only going to do it once.
We don't require it again, which is really super nice.
Okay, so if we take a look at one of the common uses of require,
a common use of require is to have sort of repeating elements on page after page.
So here I have a website, and this menu shows up both places.
It shows up both on the main page and on the install.php page.
And I want this menu, and I get tired because this is the index.php file.
This is the install.php, but I need the same darned menu on both of them.
So how do we do that?
What we do is we basically use this require to do this over and over.
This is the index.php code.
And it starts in PHP and it says, okay, let's require this top bit and
then require nav.
And the top is the non-printing stuff like the title and the head and all that stuff.
And then, nav is this little navigation bar.
And so, there are two files, top.php and nav.php.
And then, I have the body of it, which is right from here to here.
And then I include a footer.
In this case, the footer,
I have this automatic Google Translation thing that I put in my little webpage,
which translates this page into various, it uses Google's automated translation.
It translates that page into a various language.
So we can sort of see how that works.
And this is something I want to do on every page.
So I have foot.php.
So there are three files, top.php, nav.php, and
foot.php, that then I can put different content.
So this is the unique content.
So if we take a look at a different page, this page here, which is install.php,
has the same top part of the two requires and the same bottom part.
So that this stuff is the same and then this stuff is the same.
And then in the body part, I have this div, which is from here to there.
This happens to be an iframe that's pulling in a different file, yada yada,
so that comes in.
So it allows you to have these consistent elements over and
over again that put markup and repeat in.
So that's a way to break things into more than one file, and to not repeat yourself.
Don't repeat yourself.
That's what you want.
Modularity is really just the idea of capturing something once, and
reusing it over and over.
So in this series of lectures, we talked about modularity in general.
We talked about using functions that exist, like the string functions or
the array functions, making new functions.
How to pass by value and pass by reference, and
that's kind of a unique to PHP.
And how we include and require files.
And then the idea of writing code that works on various versions,
given that PHP unabashedly makes changes that are not present in all versions,
either adding or removing functionality as the PHP version kind of increases.
So I hope that's been useful to you, and we'll see you in the next lecture.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
