PHP Versions Question posted in
You can find a list of all versions here.

PHP automatically pre- and append dynamic content to output – Php versions

Is there a way to automatically include content before and after the actual output of a file?

Why? For example to use this to include everything up to the main content (dynamcally generated HTML, head, opening tags…) and after the file runs, automatically close everything up again.

I know of the ob_start approach, but I’m not sure if dynamically generated content is easy to include that way:

<?php
function bootstrap_page($content) {
    return "text before" . $content . "text after";
}

ob_start(bootstrap_page);
?>

But then, ob cannot be used to capture the output of an include within the callback, AFAIK. So that makes it hard to easily pre- and append something dynamically generated. I could use long strings in the callback function to get a static version working – but is there a way to do this more seamlessly?

In other words I’m basically trying to include a php file before and one after any (other) file I need and that – if possible reduced to a function call at the start of a given file.

The functionality I’m looking for would transform this:

<?php
bootstrap_this();
?>

<p>Lorem ipsum</p>

before.php:

<!DOCTYPE html>
<html>
  <?php include('head.php'); ?>
  <body>
    <?php if(somecondition) { ?>
    <h1>Hello, World!</h1>
    <?php } ?>

after.php:

  </body>
</html>

Into something like this:

<?php
include 'before.php';
?>
<p>Lorem ipsum</p>
<?php
include 'after.php';
?>

And in the end into:

<!DOCTYPE html>
<html>
  <?php include('head.php'); ?>
  <body>
    <?php if(somecondition) { ?>
    <h1>Hello, World!</h1>
    <?php } ?>
    <p>Lorem ipsum</p>
  </body>
</html>
Tags:

4

Answers


  1. Chosen as BEST ANSWER
    0

    Thanks to the help of @bestprogrammerintheworld, I came up with this:

    function use_template($before = 'pre', $after = 'post') {
    ob_start();
    include $before . '.php';
    $pre = ob_get_contents();
    ob_end_clean();

    ob_start();
    include $after . '.php';
    $post = ob_get_contents();
    ob_end_clean();

    $bootstrap_page = function ($content) use ($pre, $post) {
        return $pre . $content . $post;
    };

    ob_start($bootstrap_page);
}

    If this function is called a the beginning of a php file, the outputs of before.php and after.php get stored and bound to the callback. Then, after all the main output is read, everything is pieced together. No code at the end of the file required.

    Since ob cannot be run within the callback, bootstrap_page, it must be run beforehand to capture the other files first.


  2. 0

    But then, ob cannot be used to capture the output of an include within the callback, AFAIK

    AFAYK ? Would it be hard to test? As long as the include is after ob_start() and the code does not explicitly call ob_flush() before you choose to do so, then it will capture the output.

    I’m basically trying to include a php file before and one after any (other) file I need

    That implies some set sort of controlling script which calls the pre-oinclude, the main content and the post-include.

    That would be OK if HTML (not true, I’ll come back to that) did not have a defined root which should be explicitly declared. And you have the issue HTTP also has a structure which you risk subverting here – headers come before content. But leaving those aside for now, HTML requires a nested structure. All tags should be closed. Opening and closing tags in different files is messy and bad practice.

    There are a whole lot technologies which provide the end result you appear to be looking for – ESI, templating and front-controller patterns all provide this in a much more structured way.

    Login or Signup to reply.
  3. 0

    I’m not sure I see the usage of this or if I understood this correct, but if I understood it correctly you’re looking for something like this:

    <?php
function dynamice_include($before, $content, $after) {
    $dynamic_content = '';
    $dynamic_content .= include $before . '.php';
    $dynamic_content .= $content;
    $dynamic_content .= include $after . '.php';
    return $dynamic_content;
}

    Usage:

    $content = dynamice_include('before', 'Hello I am really cool','after');
echo $content;

    In before.php and after.php a return would be required, e.g.

    before.php
<?php
return "wow before";

after.php
<?php
return "wow after";

    and the result would be:

    wow beforeHello I am really coolwow after

    UPDATE:

    It seems it more something like this you’re looking for. output-buffers are the only way AFAIK to achieve this.

    This code is not optimized at all… (I just show the concept here)

    <?php
function dynamice_include($before, $content, $after) {
    $dynamic_content = '';

    ob_start();
    include $before . '.php';
    $dynamic_content .= ob_get_contents();
    ob_end_clean();  

    ob_start();
    include $content . '.php';
    $dynamic_content .= ob_get_contents();
    ob_end_clean();  

    ob_start();
    include $after . '.php';
    $dynamic_content .= ob_get_contents();    
    ob_end_clean();  

    return $dynamic_content;
}

$content = dynamice_include('before', 'dytest','after');
echo $content;

    As other stated though – it’s a lot of platforms, frameworks, template engines out there that could solve this issue. You will have do ob_start() and ob_clean within the current files content for this to work.

    UPDATE2:

    In this case I fetch current files output buffer as content.

    <?php
function dynamice_include($before, $content, $after) {
    $dynamic_content = '';

    ob_start();
    include $before . '.php';
    $dynamic_content .= ob_get_contents();
    ob_end_clean();  

    $dynamic_content .= $content;

    ob_start();
    include $after . '.php';
    $dynamic_content .= ob_get_contents();    
    ob_end_clean();  

    return $dynamic_content;
}
ob_start();
?>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    feelings    
</body>
</html>
<?php
$content = ob_get_contents();
ob_end_clean();

$content = dynamice_include('before', $content, 'after');
echo $content;
?>
    Login or Signup to reply.
  4. 0

    Isn’t that what output buffering is for?

    <?php
// Start Buffer
ob_start();

// Include before
include 'before.php'; 
?>

<p>Lorem ipsum</p>

<?php
// Include after
include 'after.php';

// Get buffered output
$page = ob_get_clean();

echo $page;
?>
    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search