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

```cpp
string_view_t get_string() const;
```

Returns the string value as a [`string_view_t`](index.md#member-types), without copying it.

## Return value

The string, as a [`string_view_t`](index.md#member-types) that points either into the document's
[`source()`](../basic_json_document/source.md) text (a string with no escape sequences), or into the document's own
buffer of decoded strings (a string that contains escape sequences, such as `#!json "\n"` or `#!json "\u00e9"`, which
had to be decoded once when the document was parsed).

## Exception safety

Strong guarantee: there are no changes to the view or the document it refers to.

## Exceptions

Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a string; example:
`"type must be string, but is array"`.

As for `BasicJsonType`, with [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) the exception names the JSON Pointer
path of the value within the document, and with [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md)
its bytes in the source text (when [`materialize()`](materialize.md) sets them).

## Complexity

Constant.

## Notes

`basic_json_view` has no `BasicJsonType` value stored anywhere, so unlike `BasicJsonType`, it has no `get_ref()` to
hand out a reference to a stored `string_t`. `get_string()` (equivalently, [`get<string_view_t>()`](get.md)) is the
zero-copy alternative: [`BasicJsonType::get_ref<const string_t&>()`](../basic_json/get_ref.md) is its closest
counterpart, except that it returns a view instead of a reference to a value that must already exist.

`get_string()` borrows the string: nothing is copied, whereas [`get<std::string>()`](get.md) copies it. For a borrowed
document, the returned [`string_view_t`](index.md#member-types) is valid as long as the caller's buffer; for an owned
one, as long as the document.

The returned [`string_view_t`](index.md#member-types) is valid exactly as long as the view that produced it — see the
[validity rules](index.md) of `basic_json_view` — and, for a string with no escapes, for as long as the document's
source text, which for a borrowed document must remain valid **and unmodified** for as long as the document exists,
since floating-point values and unescaped strings are read from the source lazily.

A string with escapes, a string of a document that owns its text, and an edited string must not be passed to
[`read()`](../basic_json_document/read.md) of the document it came from: `read()` releases them before it parses its
input. Copy the string first. (A string read unchanged from a borrowed text is not affected.)

## Examples

??? example

    The example below pulls one field out of a JSON text that stands in for a large API response, and shows that no
    `#!cpp std::string` was allocated for it: the returned view still points inside the original buffer. A field that
    contains an escape sequence cannot point into the original text — it was decoded once into the document's own
    buffer instead — but still avoids a per-field allocation.

    ```cpp
    --8<-- "examples/basic_json_view__get_string.cpp"
    ```

    Output:

    ```json
    --8<-- "examples/basic_json_view__get_string.output"
    ```

## See also

- [`get`](get.md) - convert the value to a given type (`#!cpp get<string_view_t>()` is equivalent to this function)
- [`number_token`](number_token.md) - a number's token text, without a copy
- [`BasicJsonType::get_ref`](../basic_json/get_ref.md) - the closest counterpart of `basic_json`
- [Zero-copy JSON views](../../features/json_view/reading.md#getting-values-out-without-copying) - borrowing strings instead of copying them

## Version history

- Added in version 3.13.0.