String Manipulation Techniques Every Developer Should Know

// JavaScript
const text = "Hello World";
const upper = text.toUpperCase();
console.log(upper); // "HELLO WORLD"

// Use cases:
// - Database searches (case-insensitive)
// - Comparison operations
// - Constants and environment variables
// - Headers and titles

// JavaScript
const text = "Hello World";
const lower = text.toLowerCase();
console.log(lower); // "hello world"

// Python
text = "Hello World"
lower = text.lower()
print(lower)  # "hello world"

// Use cases:
// - Email addresses
// - Usernames
// - URLs and slugs
// - Case-insensitive matching

// JavaScript - Title Case
function toTitleCase(str) {
    return str.replace(/\w\S*/g, (txt) => {
        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    });
}

console.log(toTitleCase("hello world")); // "Hello World"
console.log(toTitleCase("HELLO WORLD")); // "Hello World"

// Better version (handles more cases)
function properTitleCase(str) {
    const smallWords = /^(a|an|and|as|at|but|by|for|if|in|nor|of|on|or|the|to|up)$/i;

    return str.toLowerCase().replace(/\w+/g, (word, index) => {
        if (index > 0 && smallWords.test(word)) {
            return word;
        }
        return word.charAt(0).toUpperCase() + word.slice(1);
    });
}

console.log(properTitleCase("the quick brown fox"));
// "The Quick Brown Fox"

// JavaScript - Sentence Case
function toSentenceCase(str) {
    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}

console.log(toSentenceCase("HELLO WORLD")); // "Hello world"
console.log(toSentenceCase("hello world")); // "Hello world"

// Handle multiple sentences
function properSentenceCase(str) {
    return str.toLowerCase().replace(/(^\w|[\.!?]\s+\w)/g, (match) => {
        return match.toUpperCase();
    });
}

console.log(properSentenceCase("hello. how are you? i am fine!"));
// "Hello. How are you? I am fine!"

// JavaScript - camelCase
function toCamelCase(str) {
    return str
        .replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) => chr.toUpperCase())
        .replace(/^[A-Z]/, (match) => match.toLowerCase());
}

console.log(toCamelCase("hello world"));      // "helloWorld"
console.log(toCamelCase("Hello World"));      // "helloWorld"
console.log(toCamelCase("hello-world"));      // "helloWorld"
console.log(toCamelCase("hello_world"));      // "helloWorld"
console.log(toCamelCase("HELLO WORLD"));      // "helloWorld"

// Use cases:
// - JavaScript variable names
// - JSON property names
// - Object keys

// JavaScript - PascalCase
function toPascalCase(str) {
    return str
        .replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) => chr.toUpperCase())
        .replace(/^[a-z]/, (match) => match.toUpperCase());
}

console.log(toPascalCase("hello world"));     // "HelloWorld"
console.log(toPascalCase("hello-world"));     // "HelloWorld"
console.log(toPascalCase("hello_world"));     // "HelloWorld"

// Use cases:
// - Class names
// - Component names (React, Vue)
// - Type names (TypeScript, C#)

// JavaScript - snake_case
function toSnakeCase(str) {
    return str
        .replace(/([A-Z])/g, '_$1')
        .replace(/[^a-zA-Z0-9]+/g, '_')
        .toLowerCase()
        .replace(/^_+|_+$/g, '');
}

console.log(toSnakeCase("helloWorld"));       // "hello_world"
console.log(toSnakeCase("Hello World"));      // "hello_world"
console.log(toSnakeCase("hello-world"));      // "hello_world"

// Python style
def to_snake_case(text):
    import re
    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()

# Use cases:
# - Python variable names
# - Database column names
# - Configuration keys

// JavaScript - kebab-case
function toKebabCase(str) {
    return str
        .replace(/([a-z])([A-Z])/g, '$1-$2')
        .replace(/[\s_]+/g, '-')
        .toLowerCase();
}

console.log(toKebabCase("helloWorld"));       // "hello-world"
console.log(toKebabCase("Hello World"));      // "hello-world"
console.log(toKebabCase("hello_world"));      // "hello-world"

// Use cases:
// - URLs and slugs
// - CSS class names
// - HTML attributes
// - File names

// JavaScript - Trim both sides
const text = "   Hello World   ";
const trimmed = text.trim();
console.log(trimmed); // "Hello World"
console.log(trimmed.length); // 11

// Python
text = "   Hello World   "
trimmed = text.strip()
print(trimmed)  # "Hello World"

// PHP
$text = "   Hello World   ";
$trimmed = trim($text);
echo $trimmed;  // "Hello World"

// Custom trim characters
const custom = "...Hello...";
const result = custom.replace(/^\.+|\.+$/g, '');
console.log(result); // "Hello"

// JavaScript - Trim start/left
const text = "   Hello World   ";
const trimmed = text.trimStart(); // or trimLeft()
console.log(trimmed); // "Hello World   "

// Python
text = "   Hello World   "
trimmed = text.lstrip()
print(trimmed)  # "Hello World   "

// Remove specific characters from start
const custom = "###Hello World";
const result = custom.replace(/^#+/, '');
console.log(result); // "Hello World"

// JavaScript - Trim end/right
const text = "   Hello World   ";
const trimmed = text.trimEnd(); // or trimRight()
console.log(trimmed); // "   Hello World"

// Python
text = "   Hello World   "
trimmed = text.rstrip()
print(trimmed)  # "   Hello World"

// Remove trailing punctuation
const sentence = "Hello World!!!";
const result = sentence.replace(/!+$/, '');
console.log(result); // "Hello World"

// Remove all whitespace
const text = "Hello   World\n\tTest";
const noSpaces = text.replace(/\s+/g, '');
console.log(noSpaces); // "HelloWorldTest"

// Remove only spaces (keep tabs/newlines)
const noSpacesOnly = text.replace(/ /g, '');

// Remove extra spaces (normalize to single space)
const normalized = text.replace(/\s+/g, ' ').trim();
console.log(normalized); // "Hello World Test"

// Remove specific whitespace types
const noTabs = text.replace(/\t/g, '');
const noNewlines = text.replace(/\n/g, '');

// Normalize whitespace to single spaces
function normalizeWhitespace(str) {
    return str.replace(/\s+/g, ' ').trim();
}

const messy = "Hello    World\n\tTest   123";
console.log(normalizeWhitespace(messy));
// "Hello World Test 123"

// Real-world example: Clean user input
function cleanInput(input) {
    return input
        .trim()                    // Remove edges
        .replace(/\s+/g, ' ')      // Normalize spaces
        .replace(/[\x00-\x1F]/g, ''); // Remove control chars
}

const userInput = "  Name:   John    Doe  \n  ";
console.log(cleanInput(userInput));
// "Name: John Doe"

// Remove empty lines from text
function removeEmptyLines(text) {
    return text.split('\n')
        .filter(line => line.trim() !== '')
        .join('\n');
}

const text = `Line 1

Line 2


Line 3`;

console.log(removeEmptyLines(text));
// "Line 1
// Line 2
// Line 3"

// Remove lines with only whitespace
function removeBlankLines(text) {
    return text.replace(/^\s*$(?:\r\n?|\n)/gm, '');
}

// Collapse multiple empty lines to one
function collapseEmptyLines(text) {
    return text.replace(/\n\s*\n\s*\n/g, '\n\n');
}

// Replace first occurrence
const text = "Hello World Hello";
const result = text.replace("Hello", "Hi");
console.log(result); // "Hi World Hello"

// Python
text = "Hello World Hello"
result = text.replace("Hello", "Hi", 1)
print(result)  # "Hi World Hello"

// Case-sensitive by default
const text2 = "hello HELLO Hello";
const result2 = text2.replace("hello", "hi");
console.log(result2); // "hi HELLO Hello"

// Replace all occurrences

// Using replaceAll() (ES2021)
const text = "Hello World Hello";
const result = text.replaceAll("Hello", "Hi");
console.log(result); // "Hi World Hi"

// Using regex with g flag
const result2 = text.replace(/Hello/g, "Hi");
console.log(result2); // "Hi World Hi"

// Python - replace all by default
text = "Hello World Hello"
result = text.replace("Hello", "Hi")
print(result)  # "Hi World Hi"

// Multiple replacements at once
function replaceAll(str, find, replace) {
    return str.split(find).join(replace);
}

// Case-insensitive replacement
const text = "Hello hello HELLO";

// Using regex with i flag
const result = text.replace(/hello/gi, "Hi");
console.log(result); // "Hi Hi Hi"

// Function for case-insensitive replace
function replaceIgnoreCase(str, find, replace) {
    const regex = new RegExp(find, 'gi');
    return str.replace(regex, replace);
}

console.log(replaceIgnoreCase("Apple apple APPLE", "apple", "Orange"));
// "Orange Orange Orange"

// Replace with function callback
const text = "I have 2 apples and 5 oranges";

// Replace numbers with doubled values
const result = text.replace(/\d+/g, (match) => {
    return parseInt(match) * 2;
});
console.log(result); // "I have 4 apples and 10 oranges"

// Capitalize words
const sentence = "hello world";
const capitalized = sentence.replace(/\b\w/g, (match) => {
    return match.toUpperCase();
});
console.log(capitalized); // "Hello World"

// Transform matches
const html = "Visit https://example.com and https://test.com";
const linked = html.replace(/(https?:\/\/[^\s]+)/g, (url) => {
    return `<a href="${url}">${url}</a>`;
});

// Pattern-based replacement

// Remove HTML tags
const html = "<p>Hello <b>World</b></p>";
const text = html.replace(/<[^>]+>/g, '');
console.log(text); // "Hello World"

// Format phone number
const phone = "1234567890";
const formatted = phone.replace(/(\d{3})(\d{3})(\d{4})/, '($1) $2-$3');
console.log(formatted); // "(123) 456-7890"

// Redact sensitive data
const message = "My SSN is 123-45-6789";
const redacted = message.replace(/\d{3}-\d{2}-\d{4}/g, '*<strong>-</strong>-**<strong>');
console.log(redacted); // "My SSN is </strong>*-<strong>-</strong>**"

// Clean up quotes
const text = "She said \"hello\"";
const cleaned = text.replace(/\\"/g, '"');
console.log(cleaned); // 'She said "hello"'

// Multiple find/replace operations

// Chain replacements
const text = "Hello World! Hello Universe!";
const result = text
    .replace(/Hello/g, "Hi")
    .replace(/World/g, "Earth")
    .replace(/Universe/g, "Galaxy");
console.log(result); // "Hi Earth! Hi Galaxy!"

// Using replacement map
function replaceMultiple(str, replacements) {
    let result = str;
    for (const [find, replace] of Object.entries(replacements)) {
        result = result.replace(new RegExp(find, 'g'), replace);
    }
    return result;
}

const replacements = {
    'apple': 'orange',
    'dog': 'cat',
    'house': 'apartment'
};

const text2 = "I have an apple, a dog, and a house";
console.log(replaceMultiple(text2, replacements));
// "I have an orange, a cat, and an apartment"

// Optimized version (single pass)
function replaceMultipleOptimized(str, map) {
    const pattern = new RegExp(Object.keys(map).join('|'), 'g');
    return str.replace(pattern, (matched) => map[matched]);
}

// Split by delimiter
const csv = "apple,banana,cherry";
const fruits = csv.split(',');
console.log(fruits); // ["apple", "banana", "cherry"]

// Split by space
const sentence = "Hello World Test";
const words = sentence.split(' ');
console.log(words); // ["Hello", "World", "Test"]

// Python
text = "apple,banana,cherry"
fruits = text.split(',')
print(fruits)  # ['apple', 'banana', 'cherry']

// Split and trim
const messyCsv = "apple , banana , cherry";
const clean = messyCsv.split(',').map(s => s.trim());
console.log(clean); // ["apple", "banana", "cherry"]

// Limit number of splits
const text = "a:b:c:d:e";
const parts = text.split(':', 3);
console.log(parts); // ["a", "b", "c"]

// Split once (get first and rest)
const email = "[email protected]";
const [name, domain] = email.split('@');
console.log(name);   // "user"
console.log(domain); // "example.com"

// Python
text = "a:b:c:d:e"
parts = text.split(':', 2)  # Split at most 2 times
print(parts)  # ['a', 'b', 'c:d:e']

// Split into first and rest
function splitOnce(str, delimiter) {
    const index = str.indexOf(delimiter);
    if (index === -1) return [str];
    return [str.slice(0, index), str.slice(index + 1)];
}

// Split by pattern

// Split by any whitespace
const text = "Hello  \t World\nTest";
const words = text.split(/\s+/);
console.log(words); // ["Hello", "World", "Test"]

// Split by multiple delimiters
const data = "apple,banana;cherry|date";
const items = data.split(/[,;|]/);
console.log(items); // ["apple", "banana", "cherry", "date"]

// Split keeping delimiters
const sentence = "Hello! How are you? I'm fine.";
const parts = sentence.split(/([.!?])/);
console.log(parts);
// ["Hello", "!", " How are you", "?", " I'm fine", ".", ""]

// Split on word boundaries
const camelCase = "helloWorldTest";
const words2 = camelCase.split(/(?=[A-Z])/);
console.log(words2); // ["hello", "World", "Test"]

// Join array elements

const fruits = ["apple", "banana", "cherry"];

// Join with comma
console.log(fruits.join(',')); // "apple,banana,cherry"

// Join with space
console.log(fruits.join(' ')); // "apple banana cherry"

// Join with custom separator
console.log(fruits.join(' | ')); // "apple | banana | cherry"

// Join without separator
console.log(fruits.join('')); // "applebananacherry"

// Python
fruits = ["apple", "banana", "cherry"]
print(", ".join(fruits))  # "apple, banana, cherry"

// Build sentence
const words = ["Hello", "World"];
const sentence = words.join(' ') + '!';
console.log(sentence); // "Hello World!"

// CSV formatting
function toCSV(array) {
    return array.map(item => `"${item}"`).join(',');
}

// Split text into lines

const text = `Line 1
Line 2
Line 3`;

// Handle different line endings
const lines = text.split(/\r?\n/);
console.log(lines); // ["Line 1", "Line 2", "Line 3"]

// Split and process each line
const processed = text
    .split(/\r?\n/)
    .map(line => line.trim())
    .filter(line => line.length > 0);

// Count lines
function countLines(text) {
    return text.split(/\r?\n/).length;
}

// Get specific line
function getLine(text, lineNumber) {
    const lines = text.split(/\r?\n/);
    return lines[lineNumber - 1]; // 1-based index
}

// Process line by line
function processLines(text, callback) {
    return text
        .split(/\r?\n/)
        .map(callback)
        .join('\n');
}

// Parse CSV (basic)
function parseCSV(text) {
    return text.split('\n').map(line => line.split(','));
}

const csv = `name,age,city
John,30,NYC
Jane,25,LA`;

console.log(parseCSV(csv));
// [["name","age","city"], ["John","30","NYC"], ["Jane","25","LA"]]

// Handle quoted fields
function parseCSVQuoted(text) {
    const lines = text.split('\n');
    return lines.map(line => {
        const regex = /,(?=(?:(?:[^"]*"){2})*[^"]*$)/;
        return line.split(regex).map(field => {
            return field.replace(/^"|"$/g, '');
        });
    });
}

// CSV with headers
function parseCSVWithHeaders(text) {
    const lines = text.split('\n');
    const headers = lines[0].split(',');
    return lines.slice(1).map(line => {
        const values = line.split(',');
        return headers.reduce((obj, header, index) => {
            obj[header.trim()] = values[index].trim();
            return obj;
        }, {});
    });
}

// Test if pattern matches

const email = "[email protected]";
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
console.log(emailPattern.test(email)); // true

// Phone number validation
const phone = "(123) 456-7890";
const phonePattern = /^\(\d{3}\) \d{3}-\d{4}$/;
console.log(phonePattern.test(phone)); // true

// URL validation
const url = "https://example.com";
const urlPattern = /^https?:\/\//;
console.log(urlPattern.test(url)); // true

// Multiple patterns
function validateInput(input) {
    const patterns = {
        hasNumber: /\d/,
        hasUpper: /[A-Z]/,
        hasLower: /[a-z]/,
        hasSpecial: /[!@#$%^&*]/
    };

    return {
        hasNumber: patterns.hasNumber.test(input),
        hasUpper: patterns.hasUpper.test(input),
        hasLower: patterns.hasLower.test(input),
        hasSpecial: patterns.hasSpecial.test(input)
    };
}

// Extract matches from string

// Find first match
const text = "My email is [email protected]";
const emailPattern = /[^\s@]+@[^\s@]+\.[^\s@]+/;
const match = text.match(emailPattern);
console.log(match[0]); // "[email protected]"

// Extract with groups
const date = "Date: 2024-12-25";
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const [full, year, month, day] = date.match(datePattern);
console.log({ year, month, day });
// { year: "2024", month: "12", day: "25" }

// Find all matches
const text2 = "Call 123-456-7890 or 098-765-4321";
const phones = text2.match(/\d{3}-\d{3}-\d{4}/g);
console.log(phones);
// ["123-456-7890", "098-765-4321"]

// Find all matches with details

const text = "Email: [email protected], Contact: [email protected]";
const emailPattern = /([^\s@]+)@([^\s@]+\.\w+)/g;

// matchAll returns iterator
const matches = [...text.matchAll(emailPattern)];

matches.forEach(match => {
    console.log('Full:', match[0]);
    console.log('Username:', match[1]);
    console.log('Domain:', match[2]);
    console.log('Index:', match.index);
});

// Extract all URLs
const html = 'Visit <a href="https://example.com">here</a> or <a href="https://test.org">there</a>';
const urlPattern = /href="([^"]+)"/g;
const urls = [...html.matchAll(urlPattern)].map(m => m[1]);
console.log(urls);
// ["https://example.com", "https://test.org"]

// Named capture groups
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = "2024-12-25".match(pattern);
console.log(match.groups);
// { year: "2024", month: "12", day: "25" }

// Capture groups extract parts

// Extract name parts
const fullName = "John Doe";
const namePattern = /(\w+)\s+(\w+)/;
const [, firstName, lastName] = fullName.match(namePattern);
console.log({ firstName, lastName });
// { firstName: "John", lastName: "Doe" }

// Extract phone number parts
const phone = "(123) 456-7890";
const phonePattern = /\((\d{3})\) (\d{3})-(\d{4})/;
const [, area, exchange, number] = phone.match(phonePattern);
console.log(`${area}-${exchange}-${number}`);
// "123-456-7890"

// Named groups
const pattern = /(?<protocol>https?):\/\/(?<domain>[^\/]+)(?<path>\/.*)?/;
const url = "https://example.com/path/to/page";
const { protocol, domain, path } = url.match(pattern).groups;
console.log({ protocol, domain, path });

// Non-capturing groups
const text = "The price is $99.99";
const pricePattern = /\$(?:\d+\.\d{2})/; // ?: makes it non-capturing
const match = text.match(/\$(\d+\.\d{2})/);
console.log(match[1]); // "99.99"

// Common regex patterns

const patterns = {
    // Email
    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,

    // URL
    url: /^https?:\/\/[^\s]+$/,

    // Phone (US)
    phone: /^\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$/,

    // Zip code (US)
    zipCode: /^\d{5}(-\d{4})?$/,

    // Credit card
    creditCard: /^\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}$/,

    // IP address
    ipAddress: /^(?:\d{1,3}\.){3}\d{1,3}$/,

    // Date (YYYY-MM-DD)
    date: /^\d{4}-\d{2}-\d{2}$/,

    // Time (HH:MM)
    time: /^([01]?\d|2[0-3]):[0-5]\d$/,

    // Hex color
    hexColor: /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,

    // Username
    username: /^[a-zA-Z0-9_-]{3,16}$/,

    // Password (strong)
    strongPassword: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/
};

// Test patterns
console.log(patterns.email.test("[email protected]")); // true
console.log(patterns.phone.test("(123) 456-7890"));  // true
console.log(patterns.hexColor.test("#FF5733"));      // true

// Validation with regex

// Email validator
function isValidEmail(email) {
    const pattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return pattern.test(email);
}

// URL validator
function isValidUrl(url) {
    try {
        new URL(url);
        return true;
    } catch {
        return false;
    }
}

// Password strength
function checkPasswordStrength(password) {
    const checks = {
        length: password.length >= 8,
        uppercase: /[A-Z]/.test(password),
        lowercase: /[a-z]/.test(password),
        number: /\d/.test(password),
        special: /[!@#$%^&*(),.?":{}|<>]/.test(password)
    };

    const score = Object.values(checks).filter(Boolean).length;

    return {
        ...checks,
        score,
        strength: score < 3 ? 'weak' : score < 5 ? 'medium' : 'strong'
    };
}

// Sanitize input
function sanitizeInput(input) {
    return input
        .replace(/[<>]/g, '')          // Remove < and >
        .replace(/javascript:/gi, '')   // Remove JS protocol
        .trim();
}

// Validate phone number
function formatPhoneNumber(phone) {
    const cleaned = phone.replace(/\D/g, '');
    const match = cleaned.match(/^(\d{3})(\d{3})(\d{4})$/);
    return match ? `(${match[1]}) ${match[2]}-${match[3]}` : null;
}

// Extract substring

const text = "Hello World";

// substring(start, end)
console.log(text.substring(0, 5));  // "Hello"
console.log(text.substring(6));     // "World"

// substr(start, length) - deprecated
console.log(text.substr(0, 5));     // "Hello"
console.log(text.substr(6, 5));     // "World"

// slice(start, end) - recommended
console.log(text.slice(0, 5));      // "Hello"
console.log(text.slice(6));         // "World"
console.log(text.slice(-5));        // "World"

// Python
text = "Hello World"
print(text[0:5])    # "Hello"
print(text[6:])     # "World"
print(text[-5:])    # "World"

// Extract middle
const sentence = "The quick brown fox";
const middle = sentence.slice(4, 9);
console.log(middle); // "quick"

// Slice with negative indices

const text = "Hello World";

// From end
console.log(text.slice(-5));        // "World"
console.log(text.slice(-5, -1));    // "Worl"

// Skip first and last
console.log(text.slice(1, -1));     // "ello Worl"

// Get last N characters
function getLast(str, n) {
    return str.slice(-n);
}
console.log(getLast("Hello World", 5)); // "World"

// Get first N characters
function getFirst(str, n) {
    return str.slice(0, n);
}
console.log(getFirst("Hello World", 5)); // "Hello"

// Remove first and last char
function removeEdges(str) {
    return str.slice(1, -1);
}
console.log(removeEdges("'Hello'")); // "Hello"

// Access individual characters

const text = "Hello";

// charAt(index)
console.log(text.charAt(0));   // "H"
console.log(text.charAt(4));   // "o"

// Bracket notation (recommended)
console.log(text[0]);          // "H"
console.log(text[4]);          // "o"

// charCodeAt - get ASCII/Unicode value
console.log(text.charCodeAt(0)); // 72 (H)
console.log(text.charCodeAt(4)); // 111 (o)

// Loop through characters
for (const char of text) {
    console.log(char);
}

// Get character array
const chars = [...text];
console.log(chars); // ["H", "e", "l", "l", "o"]

// Python
text = "Hello"
print(text[0])    # "H"
print(ord(text[0]))  # 72

// Test string start and end

const text = "Hello World";

// startsWith
console.log(text.startsWith("Hello"));  // true
console.log(text.startsWith("World"));  // false
console.log(text.startsWith("World", 6)); // true (from index 6)

// endsWith
console.log(text.endsWith("World"));    // true
console.log(text.endsWith("Hello"));    // false

// includes
console.log(text.includes("llo"));      // true
console.log(text.includes("xyz"));      // false

// Python
text = "Hello World"
print(text.startswith("Hello"))  # True
print(text.endswith("World"))    # True
print("llo" in text)             # True

// Practical examples
function isImageFile(filename) {
    const extensions = ['.jpg', '.jpeg', '.png', '.gif'];
    return extensions.some(ext => filename.toLowerCase().endsWith(ext));
}

function isHttps(url) {
    return url.startsWith('https://');
}

// Find character/substring position

const text = "Hello World Hello";

// indexOf - first occurrence
console.log(text.indexOf("Hello"));    // 0
console.log(text.indexOf("World"));    // 6
console.log(text.indexOf("Hello", 1)); // 12 (start from index 1)
console.log(text.indexOf("xyz"));      // -1 (not found)

// lastIndexOf - last occurrence
console.log(text.lastIndexOf("Hello")); // 12
console.log(text.lastIndexOf("o"));     // 13

// Check if substring exists
if (text.indexOf("World") !== -1) {
    console.log("Found World");
}

// Better: use includes()
if (text.includes("World")) {
    console.log("Found World");
}

// Find all occurrences
function findAll(str, substr) {
    const positions = [];
    let pos = str.indexOf(substr);
    while (pos !== -1) {
        positions.push(pos);
        pos = str.indexOf(substr, pos + 1);
    }
    return positions;
}

console.log(findAll("Hello World Hello", "l"));
// [2, 3, 10, 15]

// Pad strings to fixed length

const text = "42";

// padStart - pad from left
console.log(text.padStart(5, "0"));  // "00042"
console.log(text.padStart(5, " "));  // "   42"

// padEnd - pad from right
console.log(text.padEnd(5, "0"));    // "42000"
console.log(text.padEnd(5, "."));    // "42..."

// Center text
function centerText(str, width, char = ' ') {
    const padding = width - str.length;
    const left = Math.floor(padding / 2);
    const right = Math.ceil(padding / 2);
    return char.repeat(left) + str + char.repeat(right);
}

console.log(centerText("Hello", 11, "-"));
// "---Hello---"

// Format numbers
function formatNumber(num, width) {
    return String(num).padStart(width, '0');
}

console.log(formatNumber(5, 3));     // "005"
console.log(formatNumber(42, 4));    // "0042"

// Table formatting
const name = "John";
const age = "30";
console.log(name.padEnd(20) + age.padStart(5));

// Basic string comparison

const str1 = "apple";
const str2 = "banana";

// Equality
console.log(str1 === str2);  // false
console.log(str1 !== str2);  // true

// Comparison operators
console.log(str1 < str2);    // true (alphabetically)
console.log(str1 > str2);    // false

// Compare ignoring case (manual)
console.log(str1.toLowerCase() === str2.toLowerCase());

// String ordering
const fruits = ["banana", "apple", "cherry"];
console.log(fruits.sort());
// ["apple", "banana", "cherry"]

// Python
str1 = "apple"
str2 = "banana"
print(str1 == str2)  # False
print(str1 < str2)   # True

// Case-insensitive comparison

function equalsIgnoreCase(str1, str2) {
    return str1.toLowerCase() === str2.toLowerCase();
}

console.log(equalsIgnoreCase("Hello", "hello"));  // true
console.log(equalsIgnoreCase("Hello", "HELLO"));  // true

// Sort case-insensitively
const names = ["John", "alice", "Bob", "charlie"];
const sorted = names.sort((a, b) => {
    return a.toLowerCase().localeCompare(b.toLowerCase());
});
console.log(sorted);
// ["alice", "Bob", "charlie", "John"]

// Python
str1 = "Hello"
str2 = "hello"
print(str1.lower() == str2.lower())  # True

// Locale-aware comparison

const strings = ["ä", "z", "a"];

// Standard sort (incorrect for some locales)
console.log(strings.sort());
// ["a", "z", "ä"]

// Locale-aware sort
console.log(strings.sort((a, b) => a.localeCompare(b)));
// ["a", "ä", "z"] (German locale)

// With specific locale
const german = ["äpfel", "zebra", "apfel"];
console.log(german.sort((a, b) => a.localeCompare(b, 'de')));

// Numeric comparison
const versions = ["1.10", "1.2", "1.1"];
console.log(versions.sort((a, b) =>
    a.localeCompare(b, undefined, { numeric: true })
));
// ["1.1", "1.2", "1.10"]

// Case and accent sensitivity
const options = {
    sensitivity: 'base'  // Ignore case and accents
};
console.log("café".localeCompare("Cafe", 'en', options));
// 0 (considered equal)

// Sort array of strings

const fruits = ["banana", "apple", "cherry", "date"];

// Alphabetical (ascending)
console.log(fruits.sort());
// ["apple", "banana", "cherry", "date"]

// Reverse alphabetical
console.log(fruits.sort().reverse());
// ["date", "cherry", "banana", "apple"]

// Or:
console.log(fruits.sort((a, b) => b.localeCompare(a)));

// Case-insensitive sort
const names = ["John", "alice", "Bob"];
names.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));

// Sort by length
const words = ["cat", "elephant", "dog", "butterfly"];
words.sort((a, b) => a.length - b.length);
console.log(words);
// ["cat", "dog", "elephant", "butterfly"]

// Python
fruits = ["banana", "apple", "cherry", "date"]
print(sorted(fruits))  # ['apple', 'banana', 'cherry', 'date']
print(sorted(fruits, reverse=True))  # Reverse

// Natural sorting (numbers in strings)

const files = ["file10.txt", "file2.txt", "file1.txt", "file20.txt"];

// Regular sort (wrong)
console.log(files.sort());
// ["file1.txt", "file10.txt", "file2.txt", "file20.txt"]

// Natural sort (correct)
console.log(files.sort((a, b) =>
    a.localeCompare(b, undefined, { numeric: true })
));
// ["file1.txt", "file2.txt", "file10.txt", "file20.txt"]

// Version numbers
const versions = ["1.10.2", "1.2.1", "1.1.0", "1.10.10"];
versions.sort((a, b) =>
    a.localeCompare(b, undefined, { numeric: true })
);
console.log(versions);
// ["1.1.0", "1.2.1", "1.10.2", "1.10.10"]

// Custom natural sort
function naturalSort(arr) {
    return arr.sort((a, b) => {
        return a.replace(/\d+/g, n =>
            n.padStart(20, '0')
        ).localeCompare(b.replace(/\d+/g, n =>
            n.padStart(20, '0')
        ));
    });
}

// Custom sort order

// Priority sort
const priorities = ["low", "high", "urgent", "medium"];
const order = { urgent: 0, high: 1, medium: 2, low: 3 };

priorities.sort((a, b) => order[a] - order[b]);
console.log(priorities);
// ["urgent", "high", "medium", "low"]

// Multi-level sort
const people = [
    { name: "John", age: 30 },
    { name: "Alice", age: 25 },
    { name: "Bob", age: 30 }
];

people.sort((a, b) => {
    // First by age
    if (a.age !== b.age) return a.age - b.age;
    // Then by name
    return a.name.localeCompare(b.name);
});

// Custom comparator
function customSort(arr, compareFn) {
    return arr.sort(compareFn);
}

// Sort by last word
const phrases = ["hello world", "test case", "another test"];
phrases.sort((a, b) => {
    const lastA = a.split(' ').pop();
    const lastB = b.split(' ').pop();
    return lastA.localeCompare(lastB);
});

// Reverse string

// Array method
const text = "Hello World";
const reversed = text.split('').reverse().join('');
console.log(reversed); // "dlroW olleH"

// Loop method
function reverseString(str) {
    let result = '';
    for (let i = str.length - 1; i >= 0; i--) {
        result += str[i];
    }
    return result;
}

// Spread operator
const reversed2 = [...text].reverse().join('');

// Reverse words (not characters)
function reverseWords(str) {
    return str.split(' ').reverse().join(' ');
}
console.log(reverseWords("Hello World"));
// "World Hello"

// Python
text = "Hello World"
reversed_text = text[::-1]
print(reversed_text)  # "dlroW olleH"

// Remove duplicate lines

function removeDuplicates(text) {
    const lines = text.split('\n');
    const unique = [...new Set(lines)];
    return unique.join('\n');
}

const text = `apple
banana
apple
cherry
banana`;

console.log(removeDuplicates(text));
// "apple
// banana
// cherry"

// Remove duplicate words
function removeDuplicateWords(sentence) {
    const words = sentence.split(' ');
    const unique = [...new Set(words)];
    return unique.join(' ');
}

// Case-insensitive duplicates
function removeDuplicatesIgnoreCase(text) {
    const lines = text.split('\n');
    const seen = new Set();
    const unique = lines.filter(line => {
        const lower = line.toLowerCase();
        if (seen.has(lower)) return false;
        seen.add(lower);
        return true;
    });
    return unique.join('\n');
}

// String templates

// Simple template
function template(str, data) {
    return str.replace(/\{(\w+)\}/g, (match, key) => {
        return data[key] || match;
    });
}

const message = template("Hello {name}, you are {age} years old", {
    name: "John",
    age: 30
});
console.log(message);
// "Hello John, you are 30 years old"

// Template literals (native)
const name = "John";
const age = 30;
const msg = `Hello ${name}, you are ${age} years old`;

// Complex template
function renderTemplate(template, data) {
    return template.replace(/\{\{(.*?)\}\}/g, (match, expr) => {
        try {
            return new Function(...Object.keys(data), `return ${expr}`)
                (...Object.values(data));
        } catch {
            return match;
        }
    });
}

const tmpl = "Total: ${price * quantity}";
const result = renderTemplate(tmpl, { price: 10, quantity: 3 });
console.log(result); // "Total: 30"

// String interpolation

// Template literals
const user = "John";
const greeting = `Hello, ${user}!`;
console.log(greeting); // "Hello, John!"

// Expressions
const a = 10;
const b = 20;
console.log(`Sum: ${a + b}`); // "Sum: 30"

// Multiline strings
const html = `
    <div>
        <h1>${title}</h1>
        <p>${content}</p>
    </div>
`;

// Tagged templates
function highlight(strings, ...values) {
    return strings.reduce((result, str, i) => {
        return result + str + (values[i] ? `<mark>${values[i]}</mark>` : '');
    }, '');
}

const searchTerm = "JavaScript";
const text = highlight`Learn ${searchTerm} programming`;
console.log(text);
// "Learn <mark>JavaScript</mark> programming"

// Python f-strings
// name = "John"
// print(f"Hello, {name}!")

// Word wrapping

function wordWrap(text, maxLength) {
    const words = text.split(' ');
    const lines = [];
    let currentLine = '';

    for (const word of words) {
        if ((currentLine + word).length > maxLength) {
            if (currentLine) lines.push(currentLine.trim());
            currentLine = word + ' ';
        } else {
            currentLine += word + ' ';
        }
    }

    if (currentLine) lines.push(currentLine.trim());
    return lines.join('\n');
}

const longText = "This is a very long sentence that needs to be wrapped to fit within a certain width";
console.log(wordWrap(longText, 30));
// "This is a very long sentence
// that needs to be wrapped to
// fit within a certain width"

// Hard wrap (break words)
function hardWrap(text, maxLength) {
    const result = [];
    for (let i = 0; i < text.length; i += maxLength) {
        result.push(text.slice(i, i + maxLength));
    }
    return result.join('\n');
}

// Truncate with ellipsis

function truncate(str, maxLength, ellipsis = '...') {
    if (str.length <= maxLength) return str;
    return str.slice(0, maxLength - ellipsis.length) + ellipsis;
}

console.log(truncate("Hello World", 8));
// "Hello..."

// Truncate at word boundary
function truncateWords(str, maxLength, ellipsis = '...') {
    if (str.length <= maxLength) return str;

    let truncated = str.slice(0, maxLength - ellipsis.length);
    const lastSpace = truncated.lastIndexOf(' ');

    if (lastSpace > 0) {
        truncated = truncated.slice(0, lastSpace);
    }

    return truncated + ellipsis;
}

console.log(truncateWords("Hello World Test", 12));
// "Hello..."

// Truncate in middle
function truncateMiddle(str, maxLength, ellipsis = '...') {
    if (str.length <= maxLength) return str;

    const charsToShow = maxLength - ellipsis.length;
    const frontChars = Math.ceil(charsToShow / 2);
    const backChars = Math.floor(charsToShow / 2);

    return str.slice(0, frontChars) + ellipsis + str.slice(-backChars);
}

console.log(truncateMiddle("verylongfilename.txt", 15));
// "verylo...me.txt"

// String concatenation performance

// ❌ Slow for many concatenations
let result = '';
for (let i = 0; i < 10000; i++) {
    result += 'text'; // Creates new string each time
}

// ✅ Fast - use array join
const parts = [];
for (let i = 0; i < 10000; i++) {
    parts.push('text');
}
const result = parts.join('');

// ✅ Fast - template literals
const items = ['a', 'b', 'c'];
const result = `Items: ${items.join(', ')}`;

// Benchmark
console.time('concat');
let str = '';
for (let i = 0; i < 10000; i++) str += i;
console.timeEnd('concat');

console.time('array');
const arr = [];
for (let i = 0; i < 10000; i++) arr.push(i);
const str2 = arr.join('');
console.timeEnd('array');

// StringBuilder pattern

class StringBuilder {
    constructor() {
        this.parts = [];
    }

    append(str) {
        this.parts.push(str);
        return this; // Chainable
    }

    appendLine(str) {
        this.parts.push(str, '\n');
        return this;
    }

    toString() {
        return this.parts.join('');
    }

    clear() {
        this.parts = [];
        return this;
    }
}

// Usage
const sb = new StringBuilder();
sb.append('Hello ')
  .append('World')
  .appendLine('!')
  .append('Next line');

console.log(sb.toString());

// Java StringBuilder
/*
StringBuilder sb = new StringBuilder();
sb.append("Hello ");
sb.append("World");
String result = sb.toString();
*/

// Optimize string operations

// ❌ Slow - repeated toLowerCase()
function containsAny(text, terms) {
    for (const term of terms) {
        if (text.toLowerCase().includes(term.toLowerCase())) {
            return true;
        }
    }
    return false;
}

// ✅ Fast - convert once
function containsAnyOptimized(text, terms) {
    const lowerText = text.toLowerCase();
    const lowerTerms = terms.map(t => t.toLowerCase());

    for (const term of lowerTerms) {
        if (lowerText.includes(term)) {
            return true;
        }
    }
    return false;
}

// Cache expensive operations
const cache = new Map();

function expensiveOperation(str) {
    if (cache.has(str)) {
        return cache.get(str);
    }

    const result = str.split('').reverse().join('');
    cache.set(str, result);
    return result;
}

// Avoid unnecessary string creation
// ❌ Slow
const parts = ['a', 'b', 'c'];
let result = '';
for (const part of parts) {
    result = result + part + ','; // Creates new string each time
}

// ✅ Fast
const result = parts.join(',') + ',';

// Regex performance

// ❌ Slow - create regex in loop
for (let i = 0; i < 1000; i++) {
    const regex = /pattern/gi; // Created 1000 times
    text.match(regex);
}

// ✅ Fast - create once
const regex = /pattern/gi;
for (let i = 0; i < 1000; i++) {
    text.match(regex);
}

// ❌ Slow - complex regex
const complexRegex = /(a+)+b/; // Catastrophic backtracking!
const text = 'a'.repeat(30) + 'c'; // Takes very long

// ✅ Fast - simple regex
const simpleRegex = /a+b/;

// Use test() instead of match() for boolean check
// ❌ Slower
if (text.match(/pattern/)) { }

// ✅ Faster
if (/pattern/.test(text)) { }

// Compile regex once for reuse
class RegexPool {
    constructor() {
        this.cache = new Map();
    }

    get(pattern, flags = '') {
        const key = `${pattern}:${flags}`;
        if (!this.cache.has(key)) {
            this.cache.set(key, new RegExp(pattern, flags));
        }
        return this.cache.get(key);
    }
}

// Validate string input

function validateInput(input, options = {}) {
    const {
        minLength = 0,
        maxLength = Infinity,
        pattern = null,
        required = false
    } = options;

    // Check required
    if (required && !input) {
        return { valid: false, error: 'Input is required' };
    }

    // Check type
    if (typeof input !== 'string') {
        return { valid: false, error: 'Input must be string' };
    }

    // Check length
    if (input.length < minLength) {
        return { valid: false, error: `Min length is ${minLength}` };
    }

    if (input.length > maxLength) {
        return { valid: false, error: `Max length is ${maxLength}` };
    }

    // Check pattern
    if (pattern && !pattern.test(input)) {
        return { valid: false, error: 'Invalid format' };
    }

    return { valid: true };
}

// Usage
const result = validateInput(userInput, {
    minLength: 3,
    maxLength: 20,
    pattern: /^[a-zA-Z0-9]+$/,
    required: true
});

if (!result.valid) {
    console.error(result.error);
}

// Handle edge cases

function safeStringOperation(input) {
    // Check null/undefined
    if (input == null) {
        return '';
    }

    // Convert to string
    input = String(input);

    // Handle empty string
    if (input.length === 0) {
        return input;
    }

    // Your operation here
    return input.trim().toLowerCase();
}

// Safe split
function safeSplit(str, delimiter = ',') {
    if (!str) return [];
    return str.split(delimiter).map(s => s.trim()).filter(Boolean);
}

// Safe substring
function safeSubstring(str, start, end) {
    if (!str) return '';
    start = Math.max(0, start);
    end = Math.min(str.length, end || str.length);
    return str.substring(start, end);
}

// Null-safe operations
const text = null;
console.log(text?.trim());        // undefined (no error)
console.log(text?.toUpperCase()); // undefined (no error)

// Handle Unicode correctly

// Emoji and special characters
const text = "Hello 👋 World 🌍";

// ❌ Wrong - splits emoji
console.log(text.split(''));
// ["H", "e", "l", "l", "o", " ", "👋", " ", "W", "o", "r", "l", "d", " ", "🌍"]
// Emoji might be split into surrogate pairs!

// ✅ Correct - use spread operator
console.log([...text]);
// Properly handles multi-byte characters

// Length with Unicode
console.log(text.length);      // 17 (counts code units)
console.log([...text].length); // 15 (counts characters)

// Reverse with emoji
function reverseUnicode(str) {
    return [...str].reverse().join('');
}

console.log(reverseUnicode("Hello 👋"));
// "👋 olleH" (correct)

// Normalize Unicode
const str1 = "café";      // é as single character
const str2 = "café";      // e + combining acute accent
console.log(str1 === str2); // false (different representations)

const normalized1 = str1.normalize('NFC');
const normalized2 = str2.normalize('NFC');
console.log(normalized1 === normalized2); // true

// Sanitize for security

// Prevent XSS
function escapeHTML(str) {
    return str
        .replace(/&/g, '&')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#039;');
}

const userInput = '<script>alert("XSS")</script>';
console.log(escapeHTML(userInput));
// "&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;"

// Prevent SQL injection
function escapeSQLString(str) {
    return str.replace(/'/g, "''");
}

// Better: Use parameterized queries!

// Remove dangerous characters
function sanitizeFilename(filename) {
    return filename
        .replace(/[^a-zA-Z0-9.-]/g, '_')
        .replace(/\.\./g, '_')
        .substring(0, 255);
}

// Validate and sanitize input
function sanitizeInput(input) {
    return input
        .trim()
        .replace(/[<>]/g, '')
        .replace(/javascript:/gi, '')
        .replace(/on\w+=/gi, '')
        .substring(0, 1000);
}