Build Your Own PHP Framework
This episode is for members only

Sign up to access "Build Your Own PHP Framework" right now.

Get started
Already a member? Sign in to continue
Playing
53. View and config helpers

Episodes

0%
Your progress
  • Total: 4h 45m
  • Played: 0m
  • Remaining: 4h 45m
Join or sign in to track your progress
01. Setting up
01. Introduction
2m 23s
0%
02. Composer and PSR-4 Autoloading
6m 17s
0%
03. Bootstrapping and structure
3m 18s
0%
04. Error reporting with Ignition
3m 49s
0%
02. Container
05. Using a container
3m 21s
0%
06. Adding service providers
5m 23s
0%
07. Autowiring with reflection
5m 5s
0%
08. Refactoring to a singleton
4m 17s
0%
03. Application config
09. Building the Config class
6m 19s
0%
10. Reading and merging config files
6m 21s
0%
11. Registering service providers through config
2m 13s
0%
12. Using env files
6m 26s
0%
04. Routing and controllers
13. Everything starts with requests
6m 52s
0%
14. Adding routing
5m 27s
0%
15. Responding in routes
4m 13s
0%
16. Cleaning up responding
7m 12s
0%
17. Defining routes in a separate file
3m 10s
0%
18. Creating a controller
5m 17s
0%
19. Using services inside controllers
2m 3s
0%
05. Views
20. Installing Twig
6m 22s
0%
21. Rendering a view
3m 36s
0%
22. Debugging in Twig
4m 45s
0%
23. Creating a base layout
3m 38s
0%
24. Page titles in Twig
4m 31s
0%
25. Creating a Twig config helper
8m 57s
0%
06. Database
26. Setting up and querying the database
13m 29s
0%
27. Working with models
4m 32s
0%
28. Creating an example user profile page
5m 49s
0%
07. Authentication
29. Setting up Sentinel
8m 36s
0%
30. Creating the registration flow
5m 44s
0%
31. Registering and authenticating a user
5m
0%
32. Showing authenticated state
5m 40s
0%
33. Logging in
3m 59s
0%
34. Logging out
3m 2s
0%
08. CSRF Protection
35. Protecting routes with CSRF
7m 51s
0%
36. Adding tokens to forms
6m 5s
0%
09. Flashing messages
37. Basic session flashing
5m 46s
0%
38. Creating a Twig helper and flashing globally
1m 39s
0%
10. Validation
39. Validating the login form
6m 40s
0%
40. Manually adding validation errors
1m 24s
0%
41. Validating the registration form
4m 5s
0%
42. Custom validation rules
9m 39s
0%
11. Middleware
43. How middleware works
5m 41s
0%
44. Adding auth middleware and grouping routes
7m 37s
0%
45. Persisting old form data
6m 53s
0%
12. Exception handling
46. Creating an exception handler
3m 38s
0%
47. Custom 404 (and other error) views
7m 27s
0%
48. Rendering views for CSRF errors
5m 18s
0%
13. Pagination
49. Paginating with Eloquent
7m 48s
0%
50. Building a pagination view with Twig
7m 38s
0%
14. Global helpers
51. Registering functions with PSR-4
1m 50s
0%
52. Container resolution helper
2m 24s
0%
53. View and config helpers
4m 12s
0%
54. Route generator helper
4m 34s
0%

Transcript

00:00
Let's just add a couple more helpers to our helpers file and then I'll let you go ahead and add any more if you need to.
00:07
So the first one and probably one that's going to be used the most often if we head over to our controller is going to be to render out a view. Now what we're doing at the moment is we are saying this view render. So we're pulling this dependency into our controller and we're saying this view render, passing everything in and then passing any data we want to send out. It would be really convenient if we could just use view to create out a view for us and then write it to the body.
00:35
What we could even do is go a step further and create a response and return that from the helper function. Let's look at doing this first and then we'll swap it over. So over in our helpers, let's go and create out a new function in here called view. Now we know that we need to pass in all of the potential data that our view needs.
00:55
So we're going to have a view in here and we're going to have an array of data that we want to send down to here. And then it's just as easy as going ahead and grabbing our view out of our container. Now, since we've already got our app helper, that's as easy as just saying app view and then render and then just passing this data directly down. Once we return that, that is all we need to do.
01:20
This is just going to work in exactly the same way. But it looks a lot cleaner over in our controllers. If you wanted to take this a step further, what you could do is you could take the response and you could take all of this data and return it. So you would only end up really with one line when you wanted to do this.
01:39
Let's go ahead and move that over now and I'll let you decide if you want to do this. So in here, let's just paste everything in that we took out of there. Let's still return this response. And in here we will go ahead and grab from here what we were returning before.
01:55
So we're basically just swapping over, creating a response in here, writing to the response and then returning that response. Again, using our app helper to render everything that we need. So now all we need to do in our home controller is get rid of all of this code and return a new view. So let's just grab what we are doing here.
02:15
Get rid of all of this. And then go ahead and return this directly, and that will work nicely. And of course, it's tidied everything up. You don't need to do this.
02:27
So I'll leave the rest of the controllers in the standard way where we're creating a response from writing to it. But you can change this over if you need to. So as the last example, I'll let you add more if you want to. Let's create out a config helper.
02:40
So let's go back over to our helpers here and let's grab out a config function. And we know that to get config, we need to pass through a key. And then potentially we need to pass through a default. By default, we'll set that to null.
02:57
Now, once again, we're going to do exactly the same thing. Use our app helper to grab config out of our container. And then we'll just say get key and default. And remember, we built this config class up earlier, so feel free to take a look at it if you need a reminder.
03:13
Okay, now we've got this. We know that we can just use this anywhere. We know that we were using our config helper a little bit earlier over in things like our view service provider. Let's just find that again.
03:25
And let's open this up and have a look. So rather than do all of this stuff here, debug and fetch this out of the container, then get app debug, we can just switch this directly over to config app and debug. And that makes it a lot shorter, cleaner, and we can even get rid of this temporary variable.
03:45
Put this directly on here and everything looks a lot neater. Again, I'll just leave this as an example and I'll let you go ahead and change this over if you want to. Okay, so it looks like this isn't working. So let's just double check what we've done here over in helpers.
03:58
And yet, sure enough, we set this as a public function, which, of course, is not right. So give that a refresh. Everything's working as normal. I'll let you go ahead and create as many of these as you want if you would like to. Just makes it a lot nicer to write our code.

Episode summary

In this episode, we're making our codebase cleaner and easier to work with by adding some handy helper functions!

First, we create a view helper. Instead of having to write out the full logic for rendering a view and returning a response inside our controllers, the new helper lets us do this in one simple line. You can use it to render your views and return the result right away, making your controller actions much simpler and tidier.

Next, we add a config helper. This function lets you quickly fetch configuration values from anywhere in your app without having to manually access the config service out of the container each time. Just pass the config key (and an optional default), and you've got what you need.

We take a quick look at how this makes things like our ViewServiceProvider much neater, swapping out some longer code for a one-liner using our new helper. Finally, there's a little debugging at the end—it's just a reminder to declare your helpers as simple functions, not as methods on a class.

By the end of the episode, you’ll have these helpers ready to go, and you’re encouraged to add any others you find useful. This will keep your codebase clean and your day-to-day programming much nicer!

Episode discussion

No comments, yet. Be the first!