# How the addUrl() Method Handles Arrays of URLs in PHP Sitemap Generator

> Learn how the addUrl() method in msbatal/php-sitemap-generator processes arrays. It iterates, detects types, and recursively calls itself for each URL entry and its metadata.

- Repository: [Mehmet Selcuk Batal/php-sitemap-generator](https://github.com/msbatal/php-sitemap-generator)
- Tags: how-to-guide
- Published: 2026-03-07

---

**The `addUrl()` method processes arrays of URLs by detecting the array type, iterating through each element, and recursively calling itself to handle individual URL entries with their optional metadata.**

In the `msbatal/php-sitemap-generator` repository, the `addUrl()` method in [`SunSitemap.php`](https://github.com/msbatal/php-sitemap-generator/blob/main/SunSitemap.php) provides a flexible interface for batching sitemap entries. While it supports adding URLs one at a time with individual parameters, it also accepts a nested array structure to process multiple URLs in a single call, as implemented in lines 48-57 of the source file.

## Array Detection and Iteration Logic

According to the source code in [`SunSitemap.php`](https://github.com/msbatal/php-sitemap-generator/blob/main/SunSitemap.php), the method first checks if the input is an array using `is_array($urls)`. When this condition evaluates to true, the method enters a dedicated processing branch rather than treating the input as a single URL string.

The method then loops through the outer array using `foreach ($urls as $url)`. Each iteration expects `$url` to be a sub-array containing up to four indexed elements representing the URL properties.

## Recursive Single-URL Processing

For each sub-array encountered, `addUrl()` invokes itself recursively. This design reuses the existing single-URL validation and storage logic implemented in the same method. The recursive call extracts array elements using `isset()` checks to handle optional parameters safely:

```php
$this->addUrl(
    isset($url[0]) ? $url[0] : null,
    isset($url[1]) ? $url[1] : null,
    isset($url[2]) ? $url[2] : null,
    isset($url[3]) ? $url[3] : null
);

```

This recursion continues until all array elements are processed, with each valid URL stored in the internal `$this->urls` collection.

## Expected Array Structure

When passing an array to `addUrl()`, each inner array must follow a specific index-based format:

- **Index 0**: The URL path (relative to `baseUrl`) — **Required**
- **Index 1**: The `lastmod` date in ISO-8601 format — Optional
- **Index 2**: The `changefreq` value (`always`, `hourly`, `daily`, `weekly`, `monthly`, `yearly`, `never`) — Optional
- **Index 3**: The `priority` value as a float between `0.0` and `1.0` — Optional

If optional indices are omitted or set to `null`, the method skips setting those attributes during the recursive call.

## Practical Implementation Example

The following example demonstrates both individual and batch URL addition using the `SunSitemap` class:

```php
<?php
require 'SunSitemap.php';

// Initialize the sitemap generator
$sitemap = new SunSitemap([
    'baseUrl' => 'https://example.com',
    'sitemapFile' => 'sitemap.xml'
]);

// Method 1: Adding URLs individually
$sitemap->addUrl('index.php', date('c'), 'daily', '1');
$sitemap->addUrl('about/contact.php', date('c'), 'monthly', '0.8');

// Method 2: Adding multiple URLs via array
$urls = [
    // Minimum required data: URL path only
    ['products/item1.php'],
    
    // Complete entry with all metadata
    ['products/item2.php', '2024-01-15', 'weekly', '0.9'],
    
    // Partial entry with selective metadata (nulls are ignored)
    ['blog/post123.php', null, 'daily']
];

// Single call processes the entire array
$sitemap->addUrl($urls);

// Generate the sitemap files
$sitemap->createSitemap();
?>

```

After processing, all URLs reside in `$this->urls`, ready for `createSitemap()` to generate the final XML files.

## Summary

- The `addUrl()` method in [`SunSitemap.php`](https://github.com/msbatal/php-sitemap-generator/blob/main/SunSitemap.php) detects arrays using `is_array()` and processes them separately from single URLs.
- It iterates through the outer array and recursively calls itself for each sub-array to leverage existing validation logic.
- Each sub-array must contain the URL path at index 0, with optional `lastmod`, `changefreq`, and `priority` values at indices 1-3.
- Omitted optional values are handled gracefully through `isset()` checks in the recursive invocation.
- All processed URLs accumulate in the `$this->urls` property for subsequent sitemap generation.

## Frequently Asked Questions

### What happens if I omit optional metadata in the URL array?

The method uses `isset()` checks when making recursive calls. If you omit indices 1-3 (or set them to `null`), the method passes `null` for those parameters, and the single-URL processing logic ignores unset values rather than adding empty XML tags.

### Can I mix single URLs and arrays in the same `addUrl()` call?

No, the method determines the processing branch based on the type of the first argument. If you pass a string, it processes a single URL. If you pass an array, it expects every element to be a sub-array representing a URL entry. To add URLs individually after a batch operation, make separate method calls.

### Where does the actual URL validation occur in the source code?

While the array-handling logic resides in lines 48-57 of [`SunSitemap.php`](https://github.com/msbatal/php-sitemap-generator/blob/main/SunSitemap.php), the actual validation, construction of the `$urlArray`, and storage into `$this->urls` occurs in the single-URL processing branch that executes when `is_array($urls)` returns false. The recursive call ensures each array element eventually hits this validation logic.

### Is there a performance benefit to using arrays versus multiple single calls?

Both approaches ultimately execute the same validation and storage logic. However, using the array syntax reduces PHP method call overhead from your application code and produces cleaner, more maintainable code when adding large batches of URLs to the sitemap.