Что такое протокол WebSocket?

Ответ

WebSocket — это протокол связи поверх TCP, обеспечивающий постоянное полнодуплексное (двустороннее) соединение между клиентом (например, браузером или мобильным приложением) и сервером. Он предназначен для обмена данными в реальном времени с минимальными задержками.

Ключевые отличия от HTTP:

Аспект HTTP WebSocket
Модель связи Запрос-ответ (полудуплексная) Постоянное полнодуплексное соединение
Инициатива отправки Только клиент Клиент и сервер могут отправлять данные в любой момент
Накладные расходы Заголовки передаются с каждым запросом Минимальные после установки соединения (handshake)

Пример использования в Swift с URLSessionWebSocketTask:

// 1. Установка соединения
let socketURL = URL(string: "wss://echo.websocket.org")! // wss — защищенный WebSocket
let webSocketTask = URLSession.shared.webSocketTask(with: socketURL)
webSocketTask.resume()

// 2. Отправка сообщения (текст или данные)
let message = URLSessionWebSocketTask.Message.string("Привет, сервер!")
webSocketTask.send(message) { error in
    if let error = error {
        print("Ошибка отправки: (error)")
    }
}

// 3. Прием сообщений (рекурсивный вызов для непрерывного прослушивания)
func listen() {
    webSocketTask.receive { result in
        switch result {
        case .success(let message):
            switch message {
            case .string(let text):
                print("Получен текст: (text)")
            case .data(let data):
                print("Получены данные: (data)")
            @unknown default:
                break
            }
            self.listen() // Слушаем следующее сообщение
        case .failure(let error):
            print("Ошибка приема: (error)")
        }
    }
}
listen()

// 4. Закрытие соединения
webSocketTask.cancel(with: .normalClosure, reason: nil)

Типичные сценарии использования: чаты, онлайн-игры, биржевые тикеры, live-уведомления, совместное редактирование документов.

Ответ 18+ 🔞

Давай разберем эту вашу технологию, а то народ путается, как хуй с пальмой. WebSocket, блядь.

Представь себе, что HTTP — это как звонить в дверь, кричать «Хлеба привез!», тебе выкидывают булку и захлопывают. Каждый раз, сука, процедура: позвонил, получил, свободен. А WebSocket — это когда ты в дверь постучал, тебе открыли, ты зашёл, сел на кухне, и теперь можешь болтать с хозяйкой хоть до утра, без этих ёбаных формальностей. И она тебе тоже может в любой момент что-то ляпнуть. Вот это и есть «полнодуплексное соединение», ёпта. Двусторонний поток без остановки.

Чем они, блядь, отличаются, если кратко:

Штука HTTP (Тупой звонок в дверь) WebSocket (Зашёл на кухню поболтать)
Как общаемся Ты спросил — тебе ответили. Всё. Постоянный канал, треплемся когда хотим.
Кто начинает Только ты, клиент. Сервер молчит, пока не спросишь. Любой! И ты, и сервер. Равенство, блядь!
Лишняя движуха С каждым чихом тащишь кучу заголовков — кто ты, откуда, куки какие. Сначала рукопожатие (handshake), а потом только чистое сообщение. Экономия, мать её!

А вот как это в Swift выглядит, на практике:

// 1. Стучимся в дверь (устанавливаем соединение)
let socketURL = URL(string: "wss://echo.websocket.org")! // wss — это как HTTPS, только для сокетов
let webSocketTask = URLSession.shared.webSocketTask(with: socketURL)
webSocketTask.resume() // Постучались, вошли, сидим.

// 2. Ляпаем что-то серверу (отправка сообщения)
let message = URLSessionWebSocketTask.Message.string("Ну чё там по базару?")
webSocketTask.send(message) { error in
    if let error = error {
        print("Ой, бля, не отправилось: (error)") // Может, сеть сдохла
    }
}

// 3. Слушаем, что нам в ответ несут (приём сообщений)
func listen() {
    webSocketTask.receive { result in
        switch result {
        case .success(let message):
            switch message {
            case .string(let text):
                print("Сервер бормочет: (text)")
            case .data(let data):
                print("Прислал какую-то бинарную хрень: (data)")
            @unknown default:
                break // На будущее, мало ли что придумают
            }
            self.listen() // И снова слушаем, пока не надоест
        case .failure(let error):
            print("Всё, приплыли, соединение сдохло: (error)")
        }
    }
}
listen() // Запускаем этот вечный цикл подслушивания

// 4. Когда наболтались — вежливо уходим (закрытие)
webSocketTask.cancel(with: .normalClosure, reason: nil) // «Всё, я пошёл, спасибо за беседу»

Где эту хуйню применяют? Да везде, где нужно, чтобы сервер мог тебе сам что-то сказать, без твоего разрешения! Онлайн-чаты (сообщения летят мгновенно), биржевые тикеры (курсы обновляются на лету), онлайн-игры (чтобы все игроки видели одно и то же), живые уведомления. Короче, везде, где «запрос-ответ» — это как ебаться через оконное стекло: неудобно, долго и холодно.