Introduction

UIActionSheet used variadic button arguments (otherButtonTitles) in older iOS APIs, which made dynamic button generation awkward. Developers often wanted to pass an array directly instead of hardcoding varargs. In legacy maintenance code, the practical solution is to initialize with minimal buttons and then add titles in a loop. For modern iOS, UIAlertController should replace UIActionSheet entirely.

This article covers both legacy array-driven patterns and migration-friendly modern alternatives.

Core Sections

1. Legacy UIActionSheet array pattern

1NSArray *options = @[ @"Edit", @"Share", @"Delete" ];
2
3UIActionSheet *sheet = [[UIActionSheet alloc] initWithTitle:@"Actions"
4                                                   delegate:self
5                                          cancelButtonTitle:@"Cancel"
6                                     destructiveButtonTitle:nil
7                                          otherButtonTitles:nil];
8
9for (NSString *title in options) {
10    [sheet addButtonWithTitle:title];
11}
12
13[sheet showInView:self.view];

This avoids variadic argument limitations.

2. Keep index mapping explicit

When buttons come from arrays, maintain deterministic mapping.

1- (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex {
2    NSString *selected = options[buttonIndex];
3    // dispatch action
4}

Account for cancel/destructive index offsets when present.

3. Swift legacy equivalent

1let options = ["Edit", "Share", "Delete"]
2let sheet = UIActionSheet(title: "Actions", delegate: self, cancelButtonTitle: "Cancel", destructiveButtonTitle: nil)
3options.forEach { sheet.addButton(withTitle: $0) }
4sheet.show(in: view)

Only relevant for maintaining old codebases.

4. Modern replacement: UIAlertController

1let alert = UIAlertController(title: "Actions", message: nil, preferredStyle: .actionSheet)
2for title in ["Edit", "Share", "Delete"] {
3    alert.addAction(UIAlertAction(title: title, style: .default) { _ in
4        // handle action
5    })
6}
7alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
8present(alert, animated: true)

This is the recommended approach for iOS 8+.

5. iPad presentation requirements

For action sheets on iPad, configure popover anchor.

alert.popoverPresentationController?.sourceView = self.view
alert.popoverPresentationController?.sourceRect = CGRect(x: 100, y: 100, width: 1, height: 1)

Missing anchor can crash on iPad.

6. Migration strategy for legacy apps

Wrap action-sheet creation in helper APIs so old call sites can transition gradually.

showLegacyOptions(options) -> internally routes to UIAlertController when possible

This minimizes churn while modernizing UX code.

Common Pitfalls

• Assuming UIActionSheet supports direct array initialization for all buttons.
• Forgetting button-index offset logic with cancel/destructive buttons.
• Maintaining deprecated API usage in new iOS code.
• Omitting popover anchor configuration for iPad action sheets.
• Scattering action-sheet creation logic without reusable helper abstractions.

Summary

For legacy UIActionSheet, pass dynamic options by adding buttons from an array after initialization. For modern iOS development, use UIAlertController action sheets instead. Keep index mapping explicit, handle iPad popover requirements, and centralize creation logic to simplify migration away from deprecated APIs.

In production teams, the technical fix is only half of the work. The other half is making the behavior repeatable across environments and future code changes. For create uiactionsheet otherbuttons by passing in array not varlist, create a lightweight implementation checklist and keep it close to the code. Include expected input shape, validation rules, failure modes, and fallback behavior. Add one “golden path” test and one “broken input” test that mirrors real incidents from logs. This quickly prevents regressions where code still compiles but semantics drift. If your stack supports typed contracts or schemas, define them early and validate at boundaries rather than deep inside business logic. Boundary validation keeps error messages local, speeds debugging, and reduces hidden coupling between services.

Operationally, add minimal observability around the branch where this logic executes. Emit structured fields that identify version, environment, and decision outcome without exposing sensitive data. During incident reviews, convert each root cause into a permanent automated test and a short runbook note. This creates cumulative reliability rather than one-off patching. Also avoid duplicating near-identical helper logic in multiple modules; centralize it and document expected usage. When framework upgrades happen, run targeted compatibility tests before broad rollout so behavior differences are found early. Teams that combine explicit contracts, focused tests, and small observability hooks usually reduce recurring bugs and spend less time in reactive debugging for create uiactionsheet otherbuttons by passing in array not varlist workflows.