Build Your Own PHP Framework

Sign in Get started

This episode is for members only

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

Already a member? Sign in to continue

Playing

51. Registering functions with PSR-4

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

02. Composer and PSR-4 Autoloading

03. Bootstrapping and structure

04. Error reporting with Ignition

02. Container

05. Using a container

06. Adding service providers

07. Autowiring with reflection

08. Refactoring to a singleton

03. Application config

09. Building the Config class

10. Reading and merging config files

11. Registering service providers through config

12. Using env files

04. Routing and controllers

13. Everything starts with requests

14. Adding routing

15. Responding in routes

16. Cleaning up responding

17. Defining routes in a separate file

18. Creating a controller

19. Using services inside controllers

05. Views

20. Installing Twig

21. Rendering a view

22. Debugging in Twig

23. Creating a base layout

24. Page titles in Twig

25. Creating a Twig config helper

06. Database

26. Setting up and querying the database

27. Working with models

28. Creating an example user profile page

07. Authentication

29. Setting up Sentinel

30. Creating the registration flow

31. Registering and authenticating a user

32. Showing authenticated state

34. Logging out

08. CSRF Protection

35. Protecting routes with CSRF

36. Adding tokens to forms

09. Flashing messages

37. Basic session flashing

38. Creating a Twig helper and flashing globally

10. Validation

39. Validating the login form

40. Manually adding validation errors

41. Validating the registration form

42. Custom validation rules

11. Middleware

43. How middleware works

44. Adding auth middleware and grouping routes

45. Persisting old form data

12. Exception handling

46. Creating an exception handler

47. Custom 404 (and other error) views

48. Rendering views for CSRF errors

13. Pagination

49. Paginating with Eloquent

50. Building a pagination view with Twig

14. Global helpers

51. Registering functions with PSR-4

52. Container resolution helper

53. View and config helpers

54. Route generator helper

Transcript

00:00

To clean up our code, we're going to be registering a few helper functions over the next few episodes. But first of all, we want to figure out how we can register these helpers so they're globally available in our application.

00:12

Normally, what we would do within a PHP application that isn't using object oriented programming is we would come over to anywhere we're sort of bootstrapping our app and we'd define a function out like this. Now, we don't really want to do that. We want everything to be nice and tidy. So we're going to leverage Composer to register these functions for us and autoload them in.

00:33

To do this, we're going to head over to Composer JSON and just below where we registered our PSR4 app namespace, we're going to go ahead and give a list of files that we want to register in. So you can add as many here as you want to. But let's go over to our main app directory and register a helpers.php file that we load in. Now, that doesn't exist at the moment.

00:53

So I'm just going to go ahead and create out a PHP file in here called helpers and we can just register any functions in here that we need. Let's just register an example name function that just returns my name and then we'll do something useful in the next few episodes. OK, so we've registered helpers. We've added that to compose.json.

01:12

The one thing that we do need to do is just dump the autoloader. So if we run Composer dump autoload, optionally passing in the optimized flag, they will now be loaded in. So we can add any functions we want now to this helpers file and we'll have them available. OK, let's go ahead and just try this out.

01:29

So let's go over to the home controller and let's just dump this at the top of the page and kill the page here. So I'm just going to invoke the name function here. If we head over to the home page, sure enough, that works really nicely. Let's go over to the next few episodes and actually register out some helpful functions that will clear up our code.

Episode overview

In this episode, we're getting ready to clean up our codebase by organizing some helper functions. Rather than scattering function definitions throughout the app (which can get messy fast), we're making these helpers globally available in a clean, maintainable way.

We start by looking at the usual approach—just declaring functions somewhere in our bootstrap code—but decide we want something tidier. So, we use Composer's ability to autoload files, setting it up in our composer.json file right underneath the PSR-4 namespace registration.

We then create a new helpers.php file in our app, register it in Composer, and add a sample name() function. After dumping Composer's autoloader, these helpers become available anywhere in our application. To make sure everything works, we quickly call our new function from the Home controller and see the expected result.

In the next episodes, we'll get into adding genuinely useful helper functions that will help tidy up our code even more!

Episode discussion

No comments, yet. Be the first!