Пути к файлам: URL vs String

1. Тема путей важнее, чем кажется

Когда вы только начинаете программировать, путь к файлу выглядит как обычный текст: "/tmp/library.json". Кажется логичным хранить это в String, печатать, склеивать, отрезать расширение… и жить спокойно. Примерно так же мы в быту храним адреса: «Ленина 10, кв. 5» — просто строка, что может пойти не так?

А пойти может многое. И как только у вас появляется CLI‑приложение (а не «одна задачка в Web‑IDE»), вы внезапно сталкиваетесь с тем, что путь должен собираться из кусочков, быть относительным или абсолютным, корректно работать с пробелами, расширениями, директориями и печататься в логах так, чтобы не вводить вас в заблуждение.

Именно поэтому сегодня мы фиксируем правило дня:

Внутри приложения пути мы храним как URL (file URL), а не как String.
Строка будет появляться только на границе: «показать пользователю» или «принять ввод».

2. Что не так с путём как со строкой

Если вы храните путь как строку, вы (часто незаметно) начинаете делать руками то, что за вас уже умеет делать стандартная библиотека и Foundation. И вот тут начинаются «тихие баги» — самые неприятные, потому что программа не падает, а просто ведёт себя странно.

Представьте типичный «строковый путь»:

let base = "/tmp"
let file = base + "/LibraryCLI" + "/" + "library" + ".json"
print(file) // /tmp/LibraryCLI/library.json

С виду всё хорошо, но теперь добавим реальность:

• где-то вы забудете слэш, и получится "/tmpLibraryCLI";
• где-то добавите лишний слэш, и получится "/tmp//LibraryCLI";
• где-то имя будет с пробелами, и часть кода начнёт «чинить» пробелы костылями;
• где-то понадобится расширение, и вы начнёте «проверять, есть ли точка».

В итоге у вас будет много кода про строки, а не про задачу приложения.

С URL мы избавляемся от этой самодеятельности: вместо «склеивания» мы добавляем компоненты пути, вместо «добавить .json руками» мы добавляем расширение, а вместо «догадок» мы можем спросить у URL, что у него за последний компонент.

3. URL в Swift — это не только про интернет

Слово URL у многих вызывает ассоциацию с вебом: https://example.com. И это нормально — большинство людей впервые видит URL именно там. Но в Swift URL — это универсальный тип «адреса ресурса», и файловая система тоже ресурс.

Мы сегодня используем URL строго как file URL (путь в файловой системе). Это значит, что у таких URL:

• схема обычно file://...
• isFileURL == true
• можно получить «путь для файловой системы» через url.path

Самое важное: для file URL почти никогда нельзя начинать с URL(string:).
URL(string:) предназначен для URL‑строк вроде https://..., и он пытается интерпретировать строку по правилам URL (с экранированием и т.д.). Файловый путь — другая история.

Правильное создание file‑URL

Сейчас мы закрепим базовый приём, который вы будете использовать постоянно. Если у вас есть путь строкой (например, из конфига или ввода пользователя), то превращаем его в file‑URL так:

import Foundation

let file = URL(fileURLWithPath: "/tmp/library.json")
print(file.isFileURL) // true
print(file.path)      // /tmp/library.json

Если вы точно знаете, что это директория, полезно прямо сказать об этом:

import Foundation

let dir = URL(fileURLWithPath: "/tmp/LibraryCLI", isDirectory: true)
print(dir.path)           // /tmp/LibraryCLI
print(dir.absoluteString) // file:///tmp/LibraryCLI/

Обратите внимание на маленькую деталь: в absoluteString директория часто заканчивается слэшем. Это не «кривой вывод» — это нормальное представление URL.

4. path и absoluteString: два разных представления

Здесь легко запутаться, поэтому давайте аккуратно. У URL есть много строковых представлений, но два самые популярные:

• url.path — это «путь в файловой системе», то, что понимает FileManager и большинство файловых API.
• url.absoluteString — это «строка URL», то есть то, что выглядит как file:///tmp/LibraryCLI/.

И эти строки не обязаны совпадать, потому что URL‑строки используют правила экранирования. Например, пробелы будут превращены в %20.

Посмотрим на это на живом примере:

import Foundation

let file = URL(fileURLWithPath: "/tmp/My Report.txt")
print(file.path)           // /tmp/My Report.txt
print(file.absoluteString) // file:///tmp/My%20Report.txt

И вот важное правило для мозга:

absoluteString удобно «посмотреть глазами» или положить в диагностический лог как URL.
path — то, что вы почти всегда передаёте в операции файловой системы.

Если перепутать, вы можете получить «вроде бы правильный текст», но не тот формат, который ожидает другая API.

Почему URL(string:) — плохая идея для файловых путей

Сейчас будет пример, который экономит новичкам часы жизни и литры чая (или кофе — тут уж как у вас с нервной системой).

import Foundation

let a = URL(string: "/tmp/report.txt")
let b = URL(fileURLWithPath: "/tmp/report.txt")

print(a as Any)        // nil (или странный URL, в зависимости от строки)
print(b.isFileURL)     // true
print(b.path)          // /tmp/report.txt

URL(string:) пытается парсить строку как URL‑адрес. А строка "/tmp/report.txt" — это не URL в привычном понимании. Это путь. Поэтому результат часто будет nil.

Даже если URL(string:) вдруг вернул что-то похожее, это может быть «удача», а не «гарантия». И такие удачи обычно заканчиваются ровно в тот момент, когда вы показываете проект преподавателю или запускаете на другой машине.

5. Сборка пути из компонентов через URL

Теперь мы переходим к главной практической выгоде URL. Как только у вас есть «база» (директория), всё остальное вы строите «как конструктор», а не как строковую арифметику.

import Foundation

let base = URL(fileURLWithPath: "/tmp", isDirectory: true)
let dataDir = base.appendingPathComponent("LibraryCLI", isDirectory: true)

print(dataDir.path) // /tmp/LibraryCLI

Обратите внимание на isDirectory: true. Это не «обязательная магия», но это отличный способ сделать намерение читаемым: мы строим директорию, а не файл. Чуть позже, когда мы начнём проверять «файл vs папка», это поможет вам лучше понимать код.

И ещё один важный приём: расширение файла добавляем не руками.

import Foundation

let dir = URL(fileURLWithPath: "/tmp/LibraryCLI", isDirectory: true)
let file = dir
    .appendingPathComponent("library")
    .appendingPathExtension("json")

print(file.path) // /tmp/LibraryCLI/library.json

Почему это лучше, чем "library" + ".json"? Потому что вы отделяете «имя» от «расширения» и не создаёте случайные монстры вроде library.json.json.

Мини‑таблица: String путь vs URL путь

Иногда полезно зафиксировать разницу не только словами, но и глазами.

Главная идея: внутри приложения — URL, на границе с API — иногда String.

Небольшая схема потока: как путь живёт в приложении

Сейчас мы зафиксируем «архитектурный» принцип на уровне мини‑схемы. Он будет повторяться весь день.

flowchart TD
    A[Ввод пользователя: String] --> B["Преобразуем в URL(fileURLWithPath:...)"]
    B --> C[Работаем внутри приложения: URL]
    C --> D[Операции ФС: FileManager/чтение/запись]
    D -->|обычно нужно| E[url.path как String]
    C -->|лог/диагностика| F[url.path или url.absoluteString]

Смысл здесь простой: строка — на входе, URL — в середине, строка — на выходе, если так требует API.

6. LibraryCLI: хелпер для построения пути к файлу

Сейчас сделаем маленький шаг в сторону нашего приложения. Мы не будем ещё создавать директории и не будем читать/писать файлы (это следующие лекции), но мы уже можем подготовить аккуратную функцию, которая строит путь к файлу данных, не прибегая к конкатенации строк.

Представим, что у нас есть идея: «файл базы» будет называться library.json. Пока мы не обсуждаем где он лежит (политика data-dir будет позже), но мы можем научиться строить URL «от заданной директории».

import Foundation

func libraryFileURL(in directory: URL) -> URL {
    // directory ожидаем как папку
    directory
        .appendingPathComponent("library")
        .appendingPathExtension("json")
}

let dir = URL(fileURLWithPath: "/tmp/LibraryCLI", isDirectory: true)
let file = libraryFileURL(in: dir)

print(file.path) // /tmp/LibraryCLI/library.json

Этот код маленький, но в нём уже есть дисциплина: функция делает одну вещь, имя говорит само за себя, а все операции над путём идут через URL‑API.

Чуть позже мы добавим второй слой: «политика выбора директории», а потом «подготовка директории через FileManager». Но фундамент — вот он.

7. Полезные свойства URL для путей

Очень легко уйти в «давайте изучим все методы URL», но нам сейчас достаточно нескольких, которые реально помогают читать код и писать меньше строковых костылей.

import Foundation

let file = URL(fileURLWithPath: "/tmp/LibraryCLI/library.json")

print(file.lastPathComponent) // library.json
print(file.pathExtension)     // json

let noExt = file.deletingPathExtension()
print(noExt.lastPathComponent) // library

Эти штуки особенно полезны в логировании и диагностике: вместо того чтобы печатать весь путь, иногда удобно показать только имя файла. И да, когда вы увидите в логах library.json.json, вы будете рады, что умеете быстро понять, откуда оно взялось.

8. Типичные ошибки

Ошибка №1: использовать URL(string:) для файлового пути.
Это происходит потому, что URL(string:) кажется «универсальным» и красиво выглядит. Но он предназначен для URL‑строк типа https://.... Для файлов всегда начинайте с URL(fileURLWithPath:), иначе вы получите nil или некорректное представление адреса.

Ошибка №2: склеивать пути строками, когда уже есть appendingPathComponent.
Это почти всегда «на автомате»: вы привыкли к строкам и оператору +. Проблема в том, что чем больше у вас «ручной сборки», тем больше мест, где можно ошибиться. URL‑методы убирают целый класс багов: слэши, пустые компоненты, странные сочетания.

Ошибка №3: путать path и absoluteString.
На глаз это выглядит как «ну это же одно и то же, только с file://». Но нет: absoluteString — это URL‑представление, где могут появляться %20 и другие экранирования. В файловые операции обычно передают path. Если в будущем вы вдруг увидите, что программа «не находит файл, хотя он есть», одна из первых проверок — что именно вы передали: path или absoluteString.

Ошибка №4: не указывать isDirectory: true там, где это папка, и потом путаться.
Код компилируется и без этого, поэтому новичок думает «ну и ладно». Но дальше вы начинаете строить более сложные пути, и читабельность падает. isDirectory: true — это не «магия», а подсказка вашему будущему «я», которое будет отлаживать проект в пятницу вечером.

Ошибка №5: хранить путь как String «везде», потому что FileManager всё равно просит строку.
Да, часть API действительно принимает String. Но это не повод превращать всю кодовую базу в «строковую кашу». Правильный стиль — хранить URL, а строку (url.path) доставать только там, где это нужно. Это делает код более типобезопасным и предсказуемым.

1

Задача

Swift SELF, 55 уровень, 0 лекция

Недоступна

Отчёт с пробелами

Отчёт с пробелами

Открыть

1

Задача

Swift SELF, 55 уровень, 0 лекция

Недоступна

Файл библиотеки

Файл библиотеки

Открыть

1

Задача

Swift SELF, 55 уровень, 0 лекция

Недоступна

Диагностика URL

Диагностика URL

Открыть

1

Задача

Swift SELF, 55 уровень, 0 лекция

Недоступна

Смена расширения

Смена расширения

Открыть