ob_start

Turn on output buffering

&reftitle.description; `bool` `ob_start` ``callable``null```callback`&null; `int` `chunk_size` 0 `int` `flags` `PHP_OUTPUT_HANDLER_STDFLAGS`

This function will turn output buffering on. While output buffering is active no output is sent from the script, instead the output is stored in an internal buffer. See outcontrol.what-output-is-buffered on exactly what output is affected.

Output buffers are stackable, that is, `ob_start` may be called while another buffer is active. If multiple output buffers are active, output is being filtered sequentially through each of them in nesting order. See outcontrol.nesting-output-buffers for more details.

See outcontrol.user-level-output-buffers for a detailed description of output buffers.

&reftitle.parameters;

`callback`

- An optional `callback` `callable` may be specified. It can also be bypassed by passing &null;.

  `callback` is invoked when the output buffer is flushed (sent), cleaned, or when the output buffer is flushed at the end of the script.

  The signature of the `callback` is as follows:

  `string```handler`` `string` `buffer` `int` `phase`

  `buffer`

- Contents of the output buffer.

`phase`

- Bitmask of `PHP_OUTPUT_HANDLER_`*`` constants . See outcontrol.flags-passed-to-output-handlers for more details.

If `callback` returns &false; the contents of the buffer are returned. See outcontrol.output-handler-return-values for more details.

Calling any of the following functions from within an output handler will result in a fatal error: `ob_clean`, `ob_end_clean`, `ob_end_flush`, `ob_flush`, `ob_get_clean`, `ob_get_flush`, `ob_start`.

See outcontrol.output-handlers and outcontrol.working-with-output-handlers for more details on `callback`s (output handlers).

`chunk_size`

- If the optional parameter `chunk_size` is passed, the buffer will be flushed after any block of code resulting in output that causes the buffer's length to equal or exceed `chunk_size`. The default value `0` means that all output is buffered until the buffer is turned off. See outcontrol.buffer-size for more details.

`flags`

- The `flags` parameter is a bitmask that controls the operations that can be performed on the output buffer. The default is to allow output buffers to be cleaned, flushed and removed, which can be set explicitly via the buffer control flags . See outcontrol.operations-on-buffers for more details.

  Each flag controls access to a set of functions, as described below:

  Constant | Functions
  `PHP_OUTPUT_HANDLER_CLEANABLE` | `ob_clean`
  `PHP_OUTPUT_HANDLER_FLUSHABLE` | `ob_flush`
  `PHP_OUTPUT_HANDLER_REMOVABLE` | `ob_end_clean`, `ob_end_flush`, `ob_get_clean`, `ob_get_flush`

&reftitle.returnvalues;

&return.success;

&reftitle.examples;

### User defined callback function example

    <?php

    function callback($buffer)
    {
      // replace all the apples with oranges
      return (str_replace("apples", "oranges", $buffer));
    }

    ob_start("callback");

    ?>
    <html>
    <body>
    <p>It's like comparing apples to oranges.</p>
    </body>
    </html>
    <?php

    ob_end_flush();

    ?>

&example.outputs;

    <html>
    <body>
    <p>It's like comparing oranges to oranges.</p>
    </body>
    </html>

### Creating an unerasable output buffer

    <?php

    ob_start(null, 0, PHP_OUTPUT_HANDLER_STDFLAGS ^ PHP_OUTPUT_HANDLER_REMOVABLE);

    ?>

&reftitle.seealso;

- `ob_get_contents`
- `ob_end_clean`
- `ob_end_flush`
- `ob_implicit_flush`
- `ob_gzhandler`
- `ob_iconv_handler`
- `mb_output_handler`
- `ob_tidyhandler`