# <small>nlohmann::basic_json_view::</small>operator<<

```cpp
std::ostream& operator<<(std::ostream& o, const basic_json_view& v);
```

Not available when [`JSON_NO_IO`](../macros/json_no_io.md) is defined.

Serializes the given view `v` to the output stream `o`, using [`dump`](dump.md) -- exactly as
`#!cpp operator<<(std::ostream&, const basic_json&)` does for a `basic_json` value.

- The indentation of the output can be controlled with the member variable `width` of the output stream `o`. For
  instance, using the manipulator `std::setw(4)` on `o` sets the indentation level to `4`, and the serialization
  result is the same as calling `#!cpp v.dump(4)`. A `width` of `0` or less (the default) selects the most compact
  representation, as `#!cpp v.dump(-1)` does.
- The indentation character can be controlled with the member variable `fill` of the output stream `o`. For instance,
  the manipulator `std::setfill('\t')` sets indentation to use a tab character rather than the default space
  character.
- As for `basic_json`, `o`'s `width` is reset to `0` after this call, whether or not it was greater than `0` before.

Numbers are always written as `#!cpp v.dump()` writes them by default, i.e. as with
[`number_format::shortest`](number_format.md); there is no way to select `#!cpp number_format::source` through the
stream.

## Parameters

`o` (in, out)
:   stream to write to

`v` (in)
:   view to serialize

## Return value

the stream `o`

## Exceptions

May throw `#!cpp std::bad_alloc`, propagated from [`dump`](dump.md#exceptions). Unlike
`#!cpp operator<<(std::ostream&, const basic_json&)`, there is no UTF-8 decoding step that could throw
[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316), and no `error_handler` to choose between --
see the [Exceptions](dump.md#exceptions) of `dump`.

## Complexity

Linear, as [`dump`](dump.md#complexity).

## Examples

??? example

    The example below writes one record out of a larger batch straight to a log stream -- compact for a one-line
    entry, and pretty-printed with `std::setw`/`std::setfill` for a readable dump -- without ever building a
    `BasicJsonType` value for the record, or for the rest of the batch.

    ```cpp
    #include <iostream>
    #include <iomanip>
    #include <nlohmann/json_view.hpp>
    
    using json_document = nlohmann::json_document;
    using json_view = nlohmann::json_view;
    
    int main()
    {
        // one order out of a large incoming batch -- write it straight to a log
        // stream without ever building a basic_json value for it, or for the
        // rest of the batch
        const json_document doc = json_document::parse(R"(
          [{"id": 1, "item": "cable"}, {"id": 2, "item": "adapter"}]
        )");
        const json_view orders = doc.root();
    
        // compact, for a one-line log entry
        std::cout << orders[1] << '\n';
    
        // std::setw sets the indentation level, exactly as for basic_json
        std::cout << std::setw(2) << orders[1] << "\n\n";
    
        // std::setfill changes the indentation character
        std::cout << std::setw(1) << std::setfill('\t') << orders[1] << '\n';
    }
    
    ```

    Output:

    ```json
    {"id":2,"item":"adapter"}
    {
      "id": 2,
      "item": "adapter"
    }
    
    {
    	"id": 2,
    	"item": "adapter"
    }
    
    ```

## See also

- [dump](dump.md) - serialize to a JSON-formatted string
- [`operator<<(std::ostream&)`](../operator_ltlt.md) - the corresponding operator for `basic_json`
- [`JSON_NO_IO`](../macros/json_no_io.md) - switch off functions relying on certain C++ I/O headers

## Version history

- Added in version 3.13.0.