---
title: "withUnsafeMutableBytes(_:)"
framework: swift
role: symbol
role_heading: Instance Method
path: "swift/arrayslice/withunsafemutablebytes(_:)"
---

# withUnsafeMutableBytes(_:)

Calls the given closure with a pointer to the underlying bytes of the array’s mutable contiguous storage.

## Declaration

```swift
mutating func withUnsafeMutableBytes<R>(_ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R
```

## Parameters

- `body`: A closure with an UnsafeMutableRawBufferPointer parameter that points to the contiguous storage for the array. If no such storage exists, it is created. If body has a return value, that value is also used as the return value for the withUnsafeMutableBytes(_:) method. The argument is valid only for the duration of the closure’s execution.

## Return Value

Return Value The return value, if any, of the body closure parameter.

## Discussion

Discussion The array’s Element type must be a trivial type, which can be copied with just a bit-for-bit copy without any indirection or reference-counting operations. Generally, native Swift types that do not contain strong or weak references are trivial, as are imported C structs and enums. The following example copies bytes from the byteValues array into numbers, an array of Int32: var numbers: [Int32] = [0, 0] var byteValues: [UInt8] = [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00]

numbers.withUnsafeMutableBytes { destBytes in     byteValues.withUnsafeBytes { srcBytes in         destBytes.copyBytes(from: srcBytes)     } } // numbers == [1, 2] note: This example shows the behavior on a little-endian platform. The pointer passed as an argument to body is valid only for the lifetime of the closure. Do not escape it from the closure for later use. warning: Do not rely on anything about the array that is the target of this method during execution of the body closure; it might not appear to have its correct value. Instead, use only the UnsafeMutableRawBufferPointer argument to body.