Ggtcf

i have too many made-functions nearly 30 of them in a file named functions.php has them ordered like this

<?php
function f1(...)......
function f2(...)......
function f3(...)......
function f4(...)......
 ------
function f30(...)......

and i have 10 pages in my website that has this in the head of it include("functions.php");

but for each page it uses a limit number of functions like

page1 = f1(), f2(), f3(), f4(), f5()
page2 = f1(), f3(), f5(), f7(), f9()
page3 = f1(), f2(), f4(), f8(), f9()
page4 = f1(), f6()
 ---------
page10 = f1(), f2(), f3(), f14(), f22(), f24(), f29()

so i thought including all 30 functions for every page is an over use for it so i thought of this

1- a page for each function included separatly for each function like

page1

include("f1.php");
include("f2.php");
include("f3.php");
include("f4.php");
include("f5.php");

2- a page contains all functions for every single page like

page1_functions.php

function f1(...)......
function f2(...)......
function f3(...)......
function f4(...)......
function f5(...)......

and included once in page1 using include("page1_functions.php");

the cons i see for each method is

all-in-one as (functions.php): unnecessary function included that may affect the performance in someway

page for each function (f1.php, f2.php,...): too many includes that may affect performance in someway

page of functions for each page (page1_functions.php, page2_functions.php): functions may be repeated multiple times and take more space and may affect the performance in someway

so i can't decide what is the best method to follow

This is too big a topic to really cover but.

Here is a simple example say you have these functions:

function f1(...)......
function f2(...)......
function f3(...)......

function f4(...)......

function f5(...)......

You always need the first 3 and not the second too.

 //Foo.php
 class Foo
 function f1(...)......
 function f2(...)......
 function f3(...)......
 

 //FooBar.php
 require_once 'Foo.php'
 class FooBar extends Foo
 function f4(...)......
 

 //FooBiz.php
 require_once 'Foo.php'
 class FooBiz extends Foo
 function f5(...)......
 

So now if I use Foo

 require_once 'Foo.php';
 $Foo = new Foo;
 $Foo->f1();

So now if I use FooBar

 require_once 'FooBar.php'; //which has its own require_once 'Foo.php';
 $FooBar = new FooBar;
 $FooBar->f1(); //from extends foo
 $FooBar->f4();

And so on. FooBiz would be the same as FooBar except that it does not have f4() instead it has all of Foo and f5(). FooBar has all of Foo and f4(). You can layer it as much as you like, you can even override methods from the "parent" class etc...

There is a lot more to it then this, but this is the basics. Plus because these are "methods" inside a class you can make a totally different class with the same method names without naming conflicts.

Then with autoloading you don't even need the require_once statements.

This is an autoloader I made, the defacto standard is to use Composer and it's autoloader, but you can play around with this one and get an idea of how they work.

https://github.com/ArtisticPhoenix/Autoloader

There are some naming conventions and stuff to consider, but if you are not using namespaces, as long as the Autoloader.php is in the same folder as the class files it should be able to load them using just:

require_once 'Autoloader.php';

$Autoloader = evoautoloaderAutoloader::getInstance();

// require_once 'Foo.php'; - no longer needed, nor is the ones in the class files
$foo = new Foo;

The idea behind this is to load the class file (which is a collection of functions and other stuff) on demand when they are called with new.