package main

import (
    "fmt"
    "strings"
)

func main() {
    header := "Content-Type"
    
    fmt.Println(strings.ToUpper(header))  // CONTENT-TYPE
    fmt.Println(strings.ToLower(header))  // content-type
    
    // Приклад: нормалізація HTTP-заголовків для порівняння
    userAgent := "Mozilla/5.0"
    if strings.ToLower(userAgent) == "mozilla/5.0" {
        fmt.Println("Браузер розпізнано")
    }
}

public class StringExample {
    public static void main(String[] args) {
        String header = "Content-Type";
        
        System.out.println(header.toUpperCase());  // CONTENT-TYPE
        System.out.println(header.toLowerCase());  // content-type
        
        // Приклад: нормалізація HTTP-заголовків
        String userAgent = "Mozilla/5.0";
        if (userAgent.toLowerCase().equals("mozilla/5.0")) {
            System.out.println("Браузер розпізнано");
        }
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    url := "https://api.example.com/users"
    filename := "config.yaml"
    authHeader := "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
    
    // Перевірка префіксу
    if strings.HasPrefix(url, "https://") {
        fmt.Println("✅ Безпечне з'єднання")
    }
    
    // Перевірка суфіксу
    if strings.HasSuffix(filename, ".yaml") || strings.HasSuffix(filename, ".yml") {
        fmt.Println("✅ YAML конфігурація")
    }
    
    // Валідація токену
    if strings.HasPrefix(authHeader, "Bearer ") {
        token := authHeader[7:]  // Видаляємо "Bearer "
        fmt.Println("Токен:", token)
    }
}

func HasPrefix(s, prefix string) bool
func HasSuffix(s, suffix string) bool

public class UrlValidator {
    public static void main(String[] args) {
        String url = "https://api.example.com/users";
        String filename = "config.yaml";
        String authHeader = "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
        
        // Перевірка префіксу
        if (url.startsWith("https://")) {
            System.out.println("✅ Безпечне з'єднання");
        }
        
        // Перевірка суфіксу
        if (filename.endsWith(".yaml") || filename.endsWith(".yml")) {
            System.out.println("✅ YAML конфігурація");
        }
        
        // Валідація токену
        if (authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            System.out.println("Токен: " + token);
        }
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    email := "user@example.com"
    query := "SELECT * FROM users"
    logLine := "[ERROR] Database connection failed"
    
    // 1. Contains — чи містить підрядок
    if strings.Contains(email, "@") {
        fmt.Println("✅ Email валідний (містить @)")
    }
    
    // 2. ContainsAny — чи містить ХОЧА Б ОДИН символ зі списку
    dangerousChars := "';--"
    if strings.ContainsAny(query, dangerousChars) {
        fmt.Println("⚠️  Підозра на SQL-ін'єкцію!")
    }
    
    // 3. ContainsRune — чи містить конкретну руну (символ Unicode)
    if strings.ContainsRune(logLine, '🔥') {
        fmt.Println("Критична помилка!")
    }
    
    // 4. Count — скільки разів зустрічається підрядок
    text := "Go Go Go!"
    count := strings.Count(text, "Go")
    fmt.Printf("Слово 'Go' зустрічається %d рази\n", count)  // 3
}

func Contains(s, substr string) bool
func ContainsAny(s, chars string) bool
func ContainsRune(s string, r rune) bool
func Count(s, substr string) int

public class StringSearch {
    public static void main(String[] args) {
        String email = "user@example.com";
        String query = "SELECT * FROM users";
        String logLine = "[ERROR] Database connection failed";
        
        // 1. contains — чи містить підрядок
        if (email.contains("@")) {
            System.out.println("✅ Email валідний (містить @)");
        }
        
        // 2. Немає ContainsAny — треба писати вручну
        String dangerousChars = "';--";
        boolean hasDangerous = false;
        for (char c : dangerousChars.toCharArray()) {
            if (query.indexOf(c) != -1) {
                hasDangerous = true;
                break;
            }
        }
        if (hasDangerous) {
            System.out.println("⚠️  Підозра на SQL-ін'єкцію!");
        }
        
        // 3. Пошук частоти входження — вручну або Apache Commons
        String text = "Go Go Go!";
        int count = text.split("Go", -1).length - 1;
        System.out.printf("Слово 'Go' зустрічається %d рази\n", count);  // 3
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    path := "/home/user/documents/file.txt"
    url := "https://api.example.com/v1/users?page=2&limit=10"
    
    // 1. Index — індекс першого входження
    atIndex := strings.Index("user@example.com", "@")
    fmt.Println("Позиція @:", atIndex)  // 4
    
    // 2. LastIndex — індекс останнього входження
    lastSlash := strings.LastIndex(path, "/")
    filename := path[lastSlash+1:]
    fmt.Println("Ім'я файлу:", filename)  // file.txt
    
    // 3. IndexAny — індекс ПЕРШОГО з будь-якого символу
    firstSpecial := strings.IndexAny(url, "?&")
    fmt.Println("Перший спецсимвол на позиції:", firstSpecial)  // 35 (позиція '?')
    
    // 4. LastIndexAny — індекс ОСТАННЬОГО з будь-якого символу
    lastSpecial := strings.LastIndexAny(url, "?&")
    fmt.Println("Останній спецсимвол на позиції:", lastSpecial)  // 42 (позиція '&')
    
    // 5. Якщо не знайдено — повертається -1
    notFound := strings.Index("Hello", "xyz")
    if notFound == -1 {
        fmt.Println("Підрядок не знайдено")
    }
}

public class StringIndexing {
    public static void main(String[] args) {
        String path = "/home/user/documents/file.txt";
        String url = "https://api.example.com/v1/users?page=2&limit=10";
        
        // 1. indexOf — індекс першого входження
        int atIndex = "user@example.com".indexOf("@");
        System.out.println("Позиція @: " + atIndex);  // 4
        
        // 2. lastIndexOf — індекс останнього входження
        int lastSlash = path.lastIndexOf("/");
        String filename = path.substring(lastSlash + 1);
        System.out.println("Ім'я файлу: " + filename);  // file.txt
        
        // 3. Немає IndexAny — треба regex або цикл
        int firstSpecial = -1;
        for (int i = 0; i < url.length(); i++) {
            if (url.charAt(i) == '?' || url.charAt(i) == '&') {
                firstSpecial = i;
                break;
            }
        }
        System.out.println("Перший спецсимвол на позиції: " + firstSpecial);
        
        // 4. Якщо не знайдено — повертається -1
        int notFound = "Hello".indexOf("xyz");
        if (notFound == -1) {
            System.out.println("Підрядок не знайдено");
        }
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    template := "Hello, {{name}}! Welcome to {{service}}."
    
    // 1. ReplaceAll — заміняє ВСІ входження
    result := strings.ReplaceAll(template, "{{name}}", "Олег")
    result = strings.ReplaceAll(result, "{{service}}", "Go Backend")
    fmt.Println(result)
    // Вивід: Hello, Олег! Welcome to Go Backend.
    
    // 2. Replace — заміняє ПЕРШІ N входжень
    text := "Go Go Go!"
    onlyFirst := strings.Replace(text, "Go", "Java", 1)
    fmt.Println(onlyFirst)  // Java Go Go!
    
    firstTwo := strings.Replace(text, "Go", "Rust", 2)
    fmt.Println(firstTwo)   // Rust Rust Go!
    
    // 3. Replace з n = -1 працює як ReplaceAll
    all := strings.Replace(text, "Go", "Python", -1)
    fmt.Println(all)        // Python Python Python!
    
    // 4. Приклад: санітизація SQL (НЕ РОБІТЬ ТАК!)
    userInput := "admin' OR '1'='1"
    // ⚠️ ПОГАНО! Використовуйте параметризовані запити!
    sanitized := strings.ReplaceAll(userInput, "'", "''")
    fmt.Println(sanitized)  // admin'' OR ''1''=''1
}

func Replace(s, old, new string, n int) string
func ReplaceAll(s, old, new string) string

public class StringReplace {
    public static void main(String[] args) {
        String template = "Hello, {{name}}! Welcome to {{service}}.";
        
        // 1. replaceAll — заміняє ВСІ входження
        String result = template.replaceAll("\\{\\{name\\}\\}", "Олег");
        result = result.replaceAll("\\{\\{service\\}\\}", "Go Backend");
        System.out.println(result);
        // Вивід: Hello, Олег! Welcome to Go Backend.
        
        // 2. replaceFirst — заміняє ПЕРШЕ входження
        String text = "Go Go Go!";
        String onlyFirst = text.replaceFirst("Go", "Java");
        System.out.println(onlyFirst);  // Java Go Go!
        
        // 3. Немає Replace з лічильником — треба regex або цикл
        
        // 4. replace (без All) — літеральна заміна
        String userInput = "admin' OR '1'='1";
        String sanitized = userInput.replace("'", "''");
        System.out.println(sanitized);  // admin'' OR ''1''=''1
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    // 1. Split — розбиває на ВСІ частини
    csv := "John,Doe,30,Engineer"
    parts := strings.Split(csv, ",")
    fmt.Println(parts)  // [John Doe 30 Engineer]
    fmt.Printf("Ім'я: %s, Прізвище: %s\n", parts[0], parts[1])
    
    // 2. SplitN — розбиває на ПЕРШІ N частин
    path := "/home/user/documents/file.txt"
    components := strings.SplitN(path, "/", 3)
    fmt.Println(components)  // [ home user/documents/file.txt]
    // Перші 2 слеші розділили, решта — як є
    
    // 3. Fields — розбиває по пробілах/табах/переносах
    logLine := "  2024-01-15  10:30:45   ERROR   Connection timeout  "
    fields := strings.Fields(logLine)
    fmt.Println(fields)  // [2024-01-15 10:30:45 ERROR Connection timeout]
    // Зайві пробіли автоматично видалені!
    
    // 4. Обробка порожніх рядків
    emptyTest := strings.Split("a,,c", ",")
    fmt.Println(emptyTest)  // [a  c] — порожній елемент залишається
    
    // 5. Join — зворотна операція (склеювання)
    words := []string{"Go", "is", "awesome"}
    sentence := strings.Join(words, " ")
    fmt.Println(sentence)  // Go is awesome
}

import java.util.Arrays;

public class StringSplit {
    public static void main(String[] args) {
        // 1. split — розбиває на ВСІ частини
        String csv = "John,Doe,30,Engineer";
        String[] parts = csv.split(",");
        System.out.println(Arrays.toString(parts));  // [John, Doe, 30, Engineer]
        System.out.printf("Ім'я: %s, Прізвище: %s\n", parts[0], parts[1]);
        
        // 2. split з ліміт — розбиває на ПЕРШІ N частин
        String path = "/home/user/documents/file.txt";
        String[] components = path.split("/", 3);
        System.out.println(Arrays.toString(components));  // [, home, user/documents/file.txt]
        
        // 3. Немає Fields — треба split("\\s+") або trim()
        String logLine = "  2024-01-15  10:30:45   ERROR   Connection timeout  ";
        String[] fields = logLine.trim().split("\\s+");
        System.out.println(Arrays.toString(fields));
        
        // 4. join — склеювання (Java 8+)
        String[] words = {"Go", "is", "awesome"};
        String sentence = String.join(" ", words);
        System.out.println(sentence);  // Go is awesome
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    // 1. TrimSpace — видаляє пробіли, таби, \n, \r з обох боків
    userInput := "  hello@example.com\t\n  "
    cleaned := strings.TrimSpace(userInput)
    fmt.Printf("'%s' → '%s'\n", userInput, cleaned)
    // '  hello@example.com 
    //   ' → 'hello@example.com'
    
    // 2. Trim — видаляє будь-які символи зі списку з обох боків
    price := "$$99.99$$"
    amount := strings.Trim(price, "$")
    fmt.Println(amount)  // 99.99
    
    path := "///home/user///"
    normalized := strings.Trim(path, "/")
    fmt.Println(normalized)  // home/user
    
    // 3. TrimLeft / TrimRight — видаляє тільки з одного боку
    code := "0001234"
    number := strings.TrimLeft(code, "0")
    fmt.Println(number)  // 1234
    
    extension := "file.txt~~~"
    filename := strings.TrimRight(extension, "~")
    fmt.Println(filename)  // file.txt
    
    // 4. Приклад: парсинг конфігурації
    configLine := "  # server_port=8080  "
    line := strings.TrimSpace(configLine)
    if !strings.HasPrefix(line, "#") {
        // Обробляємо тільки не-коментарі
        parts := strings.Split(line, "=")
        fmt.Printf("Ключ: '%s', Значення: '%s'\n", parts[0], parts[1])
    }
}

public class StringTrim {
    public static void main(String[] args) {
        // 1. trim — видаляє пробіли з обох боків (тільки ASCII ≤ 0x20!)
        String userInput = "  hello@example.com\t\n  ";
        String cleaned = userInput.trim();
        System.out.printf("'%s' → '%s'\n", userInput, cleaned);
        
        // 2. strip (Java 11+) — видаляє Unicode пробіли
        String unicode = "\u2000hello\u2000";  // En Quad (Unicode пробіл)
        System.out.println(unicode.strip());  // hello
        
        // 3. Немає Trim(cutset) — треба regex або вручну
        String price = "$$99.99$$";
        String amount = price.replaceAll("^\\$+|\\$+$", "");
        System.out.println(amount);  // 99.99
        
        // 4. stripLeading / stripTrailing (Java 11+)
        String code = "0001234";
        // Немає прямого аналогу TrimLeft — треба regex
        String number = code.replaceAll("^0+", "");
        System.out.println(number);  // 1234
    }
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    // 1. TrimPrefix — видаляє префікс (якщо є)
    url := "https://example.com/api"
    domain := strings.TrimPrefix(url, "https://")
    fmt.Println(domain)  // example.com/api
    
    // Якщо префіксу немає — рядок не змінюється
    noPrefix := strings.TrimPrefix("example.com", "https://")
    fmt.Println(noPrefix)  // example.com (без змін)
    
    // 2. TrimSuffix — видаляє суфікс (якщо є)
    filename := "report.pdf"
    name := strings.TrimSuffix(filename, ".pdf")
    fmt.Println(name)  // report
    
    // 3. Приклад: нормалізація API-шляхів
    endpoint := "/api/v1/users/"
    clean := strings.TrimPrefix(endpoint, "/")
    clean = strings.TrimSuffix(clean, "/")
    fmt.Println(clean)  // api/v1/users
    
    // 4. Відмінність від Trim: видаляє ТІЛЬКИ ОДИН РАЗ
    text := "###hello###"
    fmt.Println(strings.TrimPrefix(text, "#"))   // ##hello### (тільки 1 символ!)
    fmt.Println(strings.Trim(text, "#"))         // hello (всі символи)
}

// TrimPrefix / TrimSuffix — видаляє ТІЛЬКИ ПОВНИЙ префікс/суфікс
strings.TrimPrefix("https://example.com", "https://")  // example.com
strings.TrimPrefix("https://example.com", "http://")   // https://example.com (без змін!)

// Trim — видаляє ВСІ символи зі списку
strings.Trim("###hello###", "#")  // hello (всі '#' видалено)

public class StringPrefixSuffix {
    public static void main(String[] args) {
        // Немає TrimPrefix / TrimSuffix — треба вручну
        
        // 1. Видалення префіксу
        String url = "https://example.com/api";
        String domain = url.startsWith("https://") 
            ? url.substring(7) 
            : url;
        System.out.println(domain);  // example.com/api
        
        // 2. Видалення суфіксу
        String filename = "report.pdf";
        String name = filename.endsWith(".pdf")
            ? filename.substring(0, filename.length() - 4)
            : filename;
        System.out.println(name);  // report
        
        // 3. Apache Commons Lang: StringUtils
        // String domain = StringUtils.removeStart(url, "https://");
        // String name = StringUtils.removeEnd(filename, ".pdf");
    }
}

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    // 1. TrimFunc — видаляє символи, для яких функція повертає true
    text := "!!!Hello, World!!!"
    
    // Видаляємо всі розділові знаки з обох боків
    cleaned := strings.TrimFunc(text, func(r rune) bool {
        return unicode.IsPunct(r)  // Повертає true для !, ?, ., тощо
    })
    fmt.Println(cleaned)  // Hello, World
    
    // 2. Видаляємо цифри з початку
    code := "0001234ABC"
    withoutDigits := strings.TrimLeftFunc(code, func(r rune) bool {
        return unicode.IsDigit(r)
    })
    fmt.Println(withoutDigits)  // ABC
    
    // 3. Видаляємо пробіли та цифри з кінця
    log := "Connection timeout 500   "
    trimmed := strings.TrimRightFunc(log, func(r rune) bool {
        return unicode.IsSpace(r) || unicode.IsDigit(r)
    })
    fmt.Println(trimmed)  // Connection timeout
    
    // 4. Приклад: видалення не-ASCII символів
    mixed := "💎Hello世界"
    ascii := strings.TrimFunc(mixed, func(r rune) bool {
        return r > 127  // Видаляємо все, що не ASCII
    })
    fmt.Println(ascii)  // Hello
}

func TrimFunc(s string, f func(rune) bool) string
func TrimLeftFunc(s string, f func(rune) bool) string
func TrimRightFunc(s string, f func(rune) bool) string

public class StringTrimFunc {
    public static void main(String[] args) {
        // Немає TrimFunc — треба regex або вручну
        
        String text = "!!!Hello, World!!!";
        
        // Regex: видаляємо розділові знаки
        String cleaned = text.replaceAll("^[\\p{Punct}]+|[\\p{Punct}]+$", "");
        System.out.println(cleaned);  // Hello, World
        
        // Вручну через цикл
        String code = "0001234ABC";
        int start = 0;
        while (start < code.length() && Character.isDigit(code.charAt(start))) {
            start++;
        }
        String withoutDigits = code.substring(start);
        System.out.println(withoutDigits);  // ABC
    }
}