Complete Guide to Counting Characters, Words, and Lines: Text Analytics

// Count all characters
const text = "Hello, World!";
const charCount = text.length;
console.log(charCount); // 13

// Count with spaces
const withSpaces = text.length;

// Count without spaces
const withoutSpaces = text.replace(/\s/g, '').length;
console.log(withoutSpaces); // 12

// Python
"""
text = "Hello, World!"
char_count = len(text)  # 13
without_spaces = len(text.replace(' ', ''))  # 12
"""

// Count specific character types
function countCharTypes(text) {
  return {
    total: text.length,
    letters: (text.match(/[a-zA-Z]/g) || []).length,
    digits: (text.match(/\d/g) || []).length,
    spaces: (text.match(/\s/g) || []).length,
    punctuation: (text.match(/[.,!?;:]/g) || []).length
  };
}

// Count characters excluding whitespace
function countCharsNoSpaces(text) {
  return text.replace(/\s+/g, '').length;
}

// Count excluding all whitespace types
function countNoWhitespace(text) {
  // Removes spaces, tabs, newlines, etc.
  return text.replace(/\s/g, '').length;
}

// Count visible characters only
function countVisibleChars(text) {
  // Remove all control characters and whitespace
  return text.replace(/[\s\p{C}]/gu, '').length;
}

const text = "Hello,\n\tWorld!  ";
console.log(countCharsNoSpaces(text)); // 12
console.log(countNoWhitespace(text)); // 12

// Detailed breakdown
function characterBreakdown(text) {
  return {
    total: text.length,
    withoutSpaces: text.replace(/ /g, '').length,
    withoutWhitespace: text.replace(/\s/g, '').length,
    alphanumeric: (text.match(/[a-zA-Z0-9]/g) || []).length,
    letters: (text.match(/[a-zA-Z]/g) || []).length,
    digits: (text.match(/\d/g) || []).length
  };
}

// Basic length (UTF-16 code units)
const text = "Hello 👋 World";
console.log(text.length); // 14 (emoji counts as 2)

// Count Unicode code points
function countCodePoints(text) {
  return [...text].length;
}
console.log(countCodePoints(text)); // 13

// Count grapheme clusters (user-perceived characters)
function countGraphemes(text) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  return [...segmenter.segment(text)].length;
}
console.log(countGraphemes(text)); // 13

// Handle complex emojis
const complex = "👨‍👩‍👧‍👦"; // Family emoji
console.log(complex.length); // 11 (multiple code points)
console.log([...complex].length); // 7 (code points)
console.log(countGraphemes(complex)); // 1 (one grapheme)

// Count with emoji awareness
function smartCharCount(text) {
  return {
    codeUnits: text.length,
    codePoints: [...text].length,
    graphemes: countGraphemes(text),
    visible: text.replace(/\s/g, '').length
  };
}

// Categorize characters by type
function categorizeCharacters(text) {
  const stats = {
    uppercase: 0,
    lowercase: 0,
    digits: 0,
    spaces: 0,
    punctuation: 0,
    special: 0,
    emoji: 0
  };

  for (const char of text) {
    if (/[A-Z]/.test(char)) stats.uppercase++;
    else if (/[a-z]/.test(char)) stats.lowercase++;
    else if (/\d/.test(char)) stats.digits++;
    else if (/\s/.test(char)) stats.spaces++;
    else if (/[.,!?;:'"\-]/.test(char)) stats.punctuation++;
    else if (/\p{Emoji}/u.test(char)) stats.emoji++;
    else stats.special++;
  }

  return stats;
}

const text = "Hello World! 123 👋";
console.log(categorizeCharacters(text));
// {
//   uppercase: 2,
//   lowercase: 8,
//   digits: 3,
//   spaces: 3,
//   punctuation: 1,
//   emoji: 1,
//   special: 0
// }

// Detailed Unicode categories
function unicodeCategories(text) {
  return {
    letters: (text.match(/\p{L}/gu) || []).length,
    marks: (text.match(/\p{M}/gu) || []).length,
    numbers: (text.match(/\p{N}/gu) || []).length,
    punctuation: (text.match(/\p{P}/gu) || []).length,
    symbols: (text.match(/\p{S}/gu) || []).length,
    separators: (text.match(/\p{Z}/gu) || []).length
  };
}

// Simple word count (split by spaces)
const text = "Hello World! How are you?";
const words = text.split(/\s+/).filter(w => w.length > 0);
console.log(words.length); // 5

// More robust word counting
function countWords(text) {
  // Match word characters, including apostrophes
  const matches = text.match(/\b[\w']+\b/g);
  return matches ? matches.length : 0;
}

console.log(countWords("Hello World!")); // 2
console.log(countWords("Don't count this as three words")); // 6

// Python
"""
def count_words(text):
    import re
    words = re.findall(r'\b[\w\']+\b', text)
    return len(words)

text = "Hello World! How are you?"
print(count_words(text))  # 5
"""

// Word count with filtering
function countWordsFiltered(text, minLength = 1) {
  const words = text.match(/\b[\w']+\b/g) || [];
  return words.filter(w => w.length >= minLength).length;
}

// Advanced word counting with edge cases
function advancedWordCount(text) {
  // Normalize whitespace
  text = text.replace(/\s+/g, ' ').trim();

  // Match words with proper handling
  // Includes: letters, apostrophes, hyphens within words
  const wordPattern = /\b[a-zA-Z]+(?:[''][a-zA-Z]+)*\b/g;
  const matches = text.match(wordPattern);

  return matches ? matches.length : 0;
}

// Test cases
console.log(advancedWordCount("don't")); // 1
console.log(advancedWordCount("mother-in-law")); // 3 (or 1, depends on rules)
console.log(advancedWordCount("123 test")); // 1
console.log(advancedWordCount("test123")); // 1

// Configurable word counting
function countWordsConfigurable(text, options = {}) {
  const {
    includeHyphenated = false,  // Count "mother-in-law" as 1 word
    includeNumbers = false,     // Count "123" as a word
    minLength = 1              // Minimum word length
  } = options;

  let pattern;
  if (includeHyphenated) {
    pattern = /\b[a-zA-Z]+(?:[-'][a-zA-Z]+)*\b/g;
  } else if (includeNumbers) {
    pattern = /\b[a-zA-Z0-9]+(?:[''][a-zA-Z0-9]+)*\b/g;
  } else {
    pattern = /\b[a-zA-Z]+(?:[''][a-zA-Z]+)*\b/g;
  }

  const matches = text.match(pattern) || [];
  return matches.filter(w => w.length >= minLength).length;
}

// Handle common word counting edge cases

// Contractions
const contractions = "don't won't can't I'm you're";
console.log(countWords(contractions)); // 5 (each contraction = 1 word)

// Hyphenated words
const hyphenated = "mother-in-law twenty-one";
// Option 1: Count as separate words
const separated = hyphenated.split(/[\s-]+/).filter(w => w.length > 0).length;
// Option 2: Count as single words
const unified = hyphenated.match(/\b[\w-]+\b/g).length;

// Numbers and words
const mixed = "Test123 456test test";
const onlyLetters = (mixed.match(/\b[a-zA-Z]+\b/g) || []).length; // 1
const withNumbers = (mixed.match(/\b[\w]+\b/g) || []).length; // 3

// Email addresses and URLs
const withUrls = "Contact [email protected] or https://test.com";
const noUrls = withUrls
  .replace(/\S+@\S+\.\S+/g, '') // Remove emails
  .replace(/https?:\/\/\S+/g, ''); // Remove URLs
console.log(countWords(noUrls)); // 2 ("Contact" and "or")

// Possessives
const possessives = "John's book Mary's car";
console.log(countWords(possessives)); // 4

// Edge case handler
function robustWordCount(text) {
  // Remove URLs
  text = text.replace(/https?:\/\/\S+/gi, '');
  // Remove email addresses
  text = text.replace(/\S+@\S+\.\S+/g, '');
  // Count words
  const words = text.match(/\b[a-zA-Z]+(?:[''][a-zA-Z]+)*\b/g);
  return words ? words.length : 0;
}

// Language-specific word counting

// CJK (Chinese, Japanese, Korean) - no spaces between words
function countCJKWords(text) {
  // Chinese characters
  const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;

  // Japanese characters (Hiragana, Katakana, Kanji)
  const japaneseChars = (text.match(/[\u3040-\u309f\u30a0-\u30ff\u4e00-\u9fa5]/g) || []).length;

  // For CJK, each character often represents a word or morpheme
  return { chineseChars, japaneseChars };
}

// Arabic - right-to-left text
function countArabicWords(text) {
  // Arabic Unicode range
  const arabicWords = (text.match(/[\u0600-\u06FF]+/g) || []).length;
  return arabicWords;
}

// Universal word segmentation using Intl.Segmenter
function countWordsUniversal(text, locale = 'en') {
  if (!Intl.Segmenter) {
    // Fallback for older browsers
    return countWords(text);
  }

  const segmenter = new Intl.Segmenter(locale, { granularity: 'word' });
  const segments = [...segmenter.segment(text)];

  // Filter out non-word segments (spaces, punctuation)
  return segments.filter(s => s.isWordLike).length;
}

// Multi-language text
const multiLang = "Hello 世界 مرحبا";
console.log(countWordsUniversal(multiLang, 'en')); // Smart counting

// Count lines (including empty lines)
const text = "Line 1\nLine 2\nLine 3";
const lineCount = text.split('\n').length;
console.log(lineCount); // 3

// More robust line counting
function countLines(text) {
  if (!text || text.length === 0) return 0;

  const lines = text.split(/\r?\n/);
  return lines.length;
}

// Count non-empty lines
function countNonEmptyLines(text) {
  return text.split(/\r?\n/)
    .filter(line => line.trim().length > 0)
    .length;
}

const multiLine = "Line 1\n\nLine 2\n  \nLine 3";
console.log(countLines(multiLine)); // 5
console.log(countNonEmptyLines(multiLine)); // 3

// Python
"""
def count_lines(text):
    return len(text.split('\n'))

def count_non_empty_lines(text):
    return len([line for line in text.split('\n') if line.strip()])
"""

// Detect and handle different line endings

function detectLineEnding(text) {
  const crlfCount = (text.match(/\r\n/g) || []).length;
  const lfCount = (text.match(/(?<!\r)\n/g) || []).length;
  const crCount = (text.match(/\r(?!\n)/g) || []).length;

  if (crlfCount > 0) return 'CRLF (Windows)';
  if (lfCount > 0) return 'LF (Unix/Mac)';
  if (crCount > 0) return 'CR (Old Mac)';
  return 'No line endings';
}

// Normalize line endings
function normalizeLineEndings(text, format = '\n') {
  return text.replace(/\r\n|\r/g, format);
}

// Count lines with different line endings
function countLinesUniversal(text) {
  // Normalize first, then count
  const normalized = normalizeLineEndings(text);
  return normalized.split('\n').length;
}

// Line ending statistics
function lineEndingStats(text) {
  return {
    crlf: (text.match(/\r\n/g) || []).length,  // Windows
    lf: (text.match(/(?<!\r)\n/g) || []).length,  // Unix
    cr: (text.match(/\r(?!\n)/g) || []).length,   // Old Mac
    total: countLinesUniversal(text)
  };
}

// Count non-empty lines
function countNonEmptyLines(text) {
  return text.split(/\r?\n/)
    .filter(line => line.trim().length > 0)
    .length;
}

// Count lines with content (ignoring whitespace-only lines)
function countContentLines(text) {
  const lines = text.split(/\r?\n/);
  return lines.filter(line => /\S/.test(line)).length;
}

// Detailed line statistics
function lineStatistics(text) {
  const lines = text.split(/\r?\n/);

  return {
    total: lines.length,
    nonEmpty: lines.filter(l => l.length > 0).length,
    withContent: lines.filter(l => l.trim().length > 0).length,
    whitespaceOnly: lines.filter(l => l.length > 0 && l.trim().length === 0).length,
    empty: lines.filter(l => l.length === 0).length
  };
}

const text = "Line 1\n\nLine 2\n   \nLine 3";
console.log(lineStatistics(text));
// {
//   total: 5,
//   nonEmpty: 4,
//   withContent: 3,
//   whitespaceOnly: 1,
//   empty: 1
// }

// Count lines of code (excluding comments and blanks)
function countCodeLines(code, language = 'javascript') {
  const lines = code.split(/\r?\n/);

  const stats = {
    total: lines.length,
    code: 0,
    comments: 0,
    blank: 0,
    mixed: 0  // Lines with both code and comments
  };

  let inBlockComment = false;

  for (const line of lines) {
    const trimmed = line.trim();

    if (trimmed.length === 0) {
      stats.blank++;
      continue;
    }

    if (language === 'javascript' || language === 'java') {
      // Handle block comments
      if (trimmed.startsWith('/*')) {
        inBlockComment = true;
        stats.comments++;
        continue;
      }
      if (inBlockComment) {
        stats.comments++;
        if (trimmed.includes('*/')) {
          inBlockComment = false;
        }
        continue;
      }

      // Handle single-line comments
      if (trimmed.startsWith('//')) {
        stats.comments++;
        continue;
      }

      // Mixed: code with inline comment
      if (trimmed.includes('//')) {
        stats.mixed++;
        continue;
      }
    }

    stats.code++;
  }

  return stats;
}

const jsCode = `
// This is a comment
function test() {
  const x = 42; // inline comment

  /* Block
     comment */
  return x;
}
`;

console.log(countCodeLines(jsCode));

// Complete text statistics
function getTextStatistics(text) {
  const lines = text.split(/\r?\n/);
  const words = text.match(/\b[\w']+\b/g) || [];
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [];

  const paragraphs = text.split(/\n\s*\n/)
    .filter(p => p.trim().length > 0);

  return {
    characters: {
      total: text.length,
      withoutSpaces: text.replace(/\s/g, '').length,
      letters: (text.match(/[a-zA-Z]/g) || []).length,
      digits: (text.match(/\d/g) || []).length,
      spaces: (text.match(/\s/g) || []).length
    },
    words: {
      total: words.length,
      unique: new Set(words.map(w => w.toLowerCase())).size,
      average: words.reduce((sum, w) => sum + w.length, 0) / words.length || 0
    },
    lines: {
      total: lines.length,
      nonEmpty: lines.filter(l => l.trim().length > 0).length,
      average: text.length / lines.length || 0
    },
    sentences: {
      total: sentences.length,
      average: words.length / sentences.length || 0
    },
    paragraphs: paragraphs.length,
    readingTime: Math.ceil(words.length / 200) // 200 words per minute
  };
}

const text = "Sample text here...";
console.log(getTextStatistics(text));

// Calculate readability scores

// Flesch Reading Ease (0-100, higher = easier)
function fleschReadingEase(text) {
  const words = (text.match(/\b[\w']+\b/g) || []).length;
  const sentences = (text.match(/[.!?]+/g) || []).length;
  const syllables = countSyllables(text);

  if (sentences === 0 || words === 0) return 0;

  const score = 206.835 - 1.015 * (words / sentences) - 84.6 * (syllables / words);
  return Math.max(0, Math.min(100, score));
}

// Flesch-Kincaid Grade Level
function fleschKincaidGrade(text) {
  const words = (text.match(/\b[\w']+\b/g) || []).length;
  const sentences = (text.match(/[.!?]+/g) || []).length;
  const syllables = countSyllables(text);

  if (sentences === 0 || words === 0) return 0;

  return 0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59;
}

// Simple syllable counter
function countSyllables(text) {
  const words = text.toLowerCase().match(/\b[a-z']+\b/g) || [];
  let count = 0;

  for (const word of words) {
    // Simple syllable counting algorithm
    let syllables = word.match(/[aeiouy]+/g);
    syllables = syllables ? syllables.length : 1;

    // Adjustments
    if (word.endsWith('e')) syllables--;
    if (syllables === 0) syllables = 1;

    count += syllables;
  }

  return count;
}

// Readability interpretation
function interpretReadability(score) {
  if (score >= 90) return 'Very Easy (5th grade)';
  if (score >= 80) return 'Easy (6th grade)';
  if (score >= 70) return 'Fairly Easy (7th grade)';
  if (score >= 60) return 'Standard (8th-9th grade)';
  if (score >= 50) return 'Fairly Difficult (10th-12th grade)';
  if (score >= 30) return 'Difficult (College)';
  return 'Very Difficult (College graduate)';
}

// Vocabulary analysis
function analyzeVocabulary(text) {
  const words = text.toLowerCase()
    .match(/\b[a-z']+\b/g) || [];

  const wordFrequency = new Map();
  for (const word of words) {
    wordFrequency.set(word, (wordFrequency.get(word) || 0) + 1);
  }

  const sorted = [...wordFrequency.entries()]
    .sort((a, b) => b[1] - a[1]);

  return {
    totalWords: words.length,
    uniqueWords: wordFrequency.size,
    lexicalDiversity: wordFrequency.size / words.length,
    topWords: sorted.slice(0, 10),
    wordFrequency: Object.fromEntries(wordFrequency)
  };
}

// Word length distribution
function wordLengthDistribution(text) {
  const words = text.match(/\b[a-z']+\b/gi) || [];
  const distribution = {};

  for (const word of words) {
    const len = word.length;
    distribution[len] = (distribution[len] || 0) + 1;
  }

  return distribution;
}

// Advanced vocabulary metrics
function vocabularyMetrics(text) {
  const words = text.toLowerCase().match(/\b[a-z']+\b/g) || [];
  const unique = new Set(words);

  const longWords = words.filter(w => w.length > 6);
  const shortWords = words.filter(w => w.length <= 3);

  return {
    lexicalDiversity: unique.size / words.length,
    averageWordLength: words.reduce((s, w) => s + w.length, 0) / words.length,
    longWordRatio: longWords.length / words.length,
    shortWordRatio: shortWords.length / words.length,
    uniqueRatio: unique.size / words.length
  };
}

// Sentence statistics
function analyzeSentences(text) {
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
  const words = text.match(/\b[\w']+\b/g) || [];

  if (sentences.length === 0) {
    return {
      count: 0,
      averageLength: 0,
      averageWords: 0
    };
  }

  const sentenceLengths = sentences.map(s => s.length);
  const sentenceWordCounts = sentences.map(s =>
    (s.match(/\b[\w']+\b/g) || []).length
  );

  return {
    count: sentences.length,
    averageLength: sentenceLengths.reduce((a, b) => a + b, 0) / sentences.length,
    averageWords: sentenceWordCounts.reduce((a, b) => a + b, 0) / sentences.length,
    shortest: Math.min(...sentenceWordCounts),
    longest: Math.max(...sentenceWordCounts),
    distribution: {
      short: sentenceWordCounts.filter(c => c < 10).length,
      medium: sentenceWordCounts.filter(c => c >= 10 && c <= 20).length,
      long: sentenceWordCounts.filter(c => c > 20).length
    }
  };
}

// Sentence type detection
function detectSentenceTypes(text) {
  return {
    declarative: (text.match(/[^.!?]+\./g) || []).length,
    interrogative: (text.match(/[^.!?]+\?/g) || []).length,
    exclamatory: (text.match(/[^.!?]+!/g) || []).length
  };
}

// Count grapheme clusters (user-perceived characters)
function countGraphemes(text) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  return [...segmenter.segment(text)].length;
}

// Examples of grapheme clusters
const examples = [
  "e\u0301",           // é (e + combining acute accent)
  "👨‍👩‍👧‍👦",          // Family emoji (7 code points, 1 grapheme)
  "🏴󠁧󠁢󠁳󠁣󠁴󠁿",          // Scotland flag (7 code points, 1 grapheme)
  "👋🏻"                // Waving hand with skin tone (2 code points, 1 grapheme)
];

for (const text of examples) {
  console.log({
    text,
    length: text.length,              // UTF-16 code units
    codePoints: [...text].length,     // Unicode code points
    graphemes: countGraphemes(text)   // User-perceived characters
  });
}

// Comparison of counting methods
function compareCountingMethods(text) {
  return {
    codeUnits: text.length,
    codePoints: [...text].length,
    graphemes: countGraphemes(text),
    withoutSpaces: text.replace(/\s/g, '').length,
    visible: countGraphemes(text.replace(/\s/g, ''))
  };
}

// Count emojis in text
function countEmojis(text) {
  // Unicode emoji ranges
  const emojiRegex = /\p{Emoji}/gu;
  const matches = text.match(emojiRegex) || [];
  return matches.length;
}

// More accurate emoji counting with grapheme clusters
function countEmojisAccurate(text) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  const segments = [...segmenter.segment(text)];

  return segments.filter(s => /\p{Emoji}/u.test(s.segment)).length;
}

// Examples
const texts = [
  "Hello 👋 World 🌍",
  "Family: 👨‍👩‍👧‍👦",
  "Flags: 🇺🇸 🇬🇧 🇫🇷"
];

for (const text of texts) {
  console.log({
    text,
    simpleCount: countEmojis(text),
    accurateCount: countEmojisAccurate(text)
  });
}

// Extract all emojis
function extractEmojis(text) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  const segments = [...segmenter.segment(text)];

  return segments
    .filter(s => /\p{Emoji}/u.test(s.segment))
    .map(s => s.segment);
}

// Emoji statistics
function emojiStats(text) {
  const emojis = extractEmojis(text);
  const frequency = new Map();

  for (const emoji of emojis) {
    frequency.set(emoji, (frequency.get(emoji) || 0) + 1);
  }

  return {
    total: emojis.length,
    unique: frequency.size,
    frequency: Object.fromEntries(frequency)
  };
}

// Handle combining characters (diacritics)
const examples = {
  precomposed: "café",           // Single code point é
  decomposed: "cafe\u0301",      // e + combining acute accent
  complex: "ḱṷṓn"               // Multiple combining marks
};

// Count considering combining characters
function countWithCombining(text) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  return [...segmenter.segment(text)].length;
}

console.log({
  precomposed: countWithCombining(examples.precomposed),  // 4
  decomposed: countWithCombining(examples.decomposed),    // 4 (not 5!)
  complex: countWithCombining(examples.complex)           // 4
});

// Detect combining characters
function hasCombiningCharacters(text) {
  // Unicode combining diacritical marks range
  return /[\u0300-\u036f]/u.test(text);
}

// Normalize for consistent counting
function normalizedCount(text, form = 'NFC') {
  const normalized = text.normalize(form);
  return [...normalized].length;
}

// Unicode normalization for consistent counting

// Different representations of "café"
const variants = {
  nfc: "café".normalize('NFC'),      // Canonical composition
  nfd: "café".normalize('NFD'),      // Canonical decomposition
  nfkc: "café".normalize('NFKC'),    // Compatibility composition
  nfkd: "café".normalize('NFKD')     // Compatibility decomposition
};

// Count each variant
for (const [form, text] of Object.entries(variants)) {
  console.log({
    form,
    codePoints: [...text].length,
    graphemes: countGraphemes(text),
    bytes: new Blob([text]).size
  });
}

// Normalize before counting
function normalizedCharCount(text, normalizationForm = 'NFC') {
  const normalized = text.normalize(normalizationForm);
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  return [...segmenter.segment(normalized)].length;
}

// Compare strings with normalization
function compareNormalized(str1, str2) {
  return str1.normalize('NFC') === str2.normalize('NFC');
}

// Example: These should be equal
const s1 = "café";           // Precomposed
const s2 = "cafe\u0301";     // Decomposed
console.log(s1 === s2);                    // false
console.log(compareNormalized(s1, s2));    // true

// Efficient single-pass counting
function efficientCount(text) {
  let chars = 0;
  let charsNoSpace = 0;
  let words = 0;
  let lines = 1;
  let inWord = false;

  for (let i = 0; i < text.length; i++) {
    const char = text[i];
    chars++;

    if (char === '\n') {
      lines++;
      inWord = false;
    } else if (/\s/.test(char)) {
      if (char !== '\n') charsNoSpace++;
      inWord = false;
    } else {
      charsNoSpace++;
      if (!inWord) {
        words++;
        inWord = true;
      }
    }
  }

  return { chars, charsNoSpace, words, lines };
}

// Compare performance
console.time('Multiple passes');
const text = "Sample text...".repeat(1000);
const chars = text.length;
const words = (text.match(/\b[\w']+\b/g) || []).length;
const lines = text.split('\n').length;
console.timeEnd('Multiple passes');

console.time('Single pass');
const stats = efficientCount(text);
console.timeEnd('Single pass');

// Result: Single pass is significantly faster

// Stream processing for large files (Node.js)
const fs = require('fs');
const readline = require('readline');

async function countLargeFile(filepath) {
  const fileStream = fs.createReadStream(filepath, { encoding: 'utf8' });

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  let stats = {
    chars: 0,
    words: 0,
    lines: 0
  };

  for await (const line of rl) {
    stats.lines++;
    stats.chars += line.length + 1; // +1 for newline
    const words = line.match(/\b[\w']+\b/g);
    stats.words += words ? words.length : 0;
  }

  return stats;
}

// Usage
countLargeFile('large-file.txt').then(stats => {
  console.log(stats);
});

// Chunked processing for browser
function processLargeTextInChunks(text, chunkSize = 10000) {
  const chunks = Math.ceil(text.length / chunkSize);
  let stats = { chars: 0, words: 0, lines: 0 };

  for (let i = 0; i < chunks; i++) {
    const start = i * chunkSize;
    const end = Math.min((i + 1) * chunkSize, text.length);
    const chunk = text.slice(start, end);

    stats.chars += chunk.length;
    stats.words += (chunk.match(/\b[\w']+\b/g) || []).length;
    stats.lines += (chunk.match(/\n/g) || []).length;
  }

  return stats;
}

// Debounced counting for real-time editors
function debounce(func, delay) {
  let timeoutId;
  return function (...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => func.apply(this, args), delay);
  };
}

// Live counter component
class LiveTextCounter {
  constructor(textElement, statsElement, debounceMs = 300) {
    this.textElement = textElement;
    this.statsElement = statsElement;

    // Debounced update function
    this.debouncedUpdate = debounce(
      () => this.updateStats(),
      debounceMs
    );

    // Listen to input events
    this.textElement.addEventListener('input', () => {
      this.debouncedUpdate();
    });
  }

  updateStats() {
    const text = this.textElement.value;
    const stats = this.countText(text);
    this.displayStats(stats);
  }

  countText(text) {
    return {
      characters: text.length,
      charactersNoSpaces: text.replace(/\s/g, '').length,
      words: (text.match(/\b[\w']+\b/g) || []).length,
      lines: text.split(/\r?\n/).length,
      sentences: (text.match(/[.!?]+/g) || []).length
    };
  }

  displayStats(stats) {
    this.statsElement.textContent = `
      Characters: ${stats.characters}
      Words: ${stats.words}
      Lines: ${stats.lines}
    `;
  }
}

// Usage
const textarea = document.querySelector('textarea');
const statsDiv = document.querySelector('#stats');
const counter = new LiveTextCounter(textarea, statsDiv);

// Cache results for unchanged content
class CachedTextCounter {
  constructor() {
    this.cache = new Map();
  }

  count(text) {
    // Generate cache key (hash of text)
    const cacheKey = this.hashText(text);

    // Check cache
    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey);
    }

    // Compute stats
    const stats = this.computeStats(text);

    // Store in cache (with size limit)
    if (this.cache.size > 100) {
      // Remove oldest entry
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }

    this.cache.set(cacheKey, stats);
    return stats;
  }

  hashText(text) {
    // Simple hash for demonstration
    let hash = 0;
    for (let i = 0; i < text.length; i++) {
      hash = ((hash << 5) - hash) + text.charCodeAt(i);
      hash = hash & hash; // Convert to 32-bit integer
    }
    return hash;
  }

  computeStats(text) {
    return {
      characters: text.length,
      words: (text.match(/\b[\w']+\b/g) || []).length,
      lines: text.split(/\r?\n/).length
    };
  }

  clearCache() {
    this.cache.clear();
  }
}

// Usage
const counter = new CachedTextCounter();
console.log(counter.count("Same text...")); // Computed
console.log(counter.count("Same text...")); // From cache (faster)

# wc (word count) command basics

# Count lines, words, and characters
wc file.txt
# Output: lines words bytes filename

# Count lines only
wc -l file.txt

# Count words only
wc -w file.txt

# Count characters (bytes)
wc -c file.txt

# Count characters (Unicode-aware)
wc -m file.txt

# Multiple files
wc file1.txt file2.txt file3.txt

# Count from stdin
echo "Hello World" | wc -w
# Output: 2

# Count files in directory
ls -1 | wc -l

# Suppress filename in output
wc -l < file.txt

# Advanced wc usage

# Count total lines across multiple files
wc -l *.txt | tail -1

# Count longest line length
wc -L file.txt

# Count all JavaScript files in project
find . -name "*.js" | xargs wc -l

# Count with specific file types
find . -type f -name "*.py" -exec wc -l {} + | sort -rn

# Count code excluding comments and blanks
grep -v "^\s*#" script.py | grep -v "^\s*$" | wc -l

# Count unique lines
sort file.txt | uniq | wc -l

# Count occurrences of pattern
grep -c "error" logfile.txt

# Count non-empty lines
grep -cv "^$" file.txt

# Word frequency count
tr -s ' ' '\n' < file.txt | sort | uniq -c | sort -rn

# Count lines in largest file
wc -l *.txt | sort -rn | head -1

# Custom counting with awk

# Count lines (like wc -l)
awk 'END {print NR}' file.txt

# Count words
awk '{total += NF} END {print total}' file.txt

# Count characters
awk '{total += length($0)} END {print total}' file.txt

# Count non-empty lines
awk 'NF > 0 {count++} END {print count}' file.txt

# Count lines longer than 80 characters
awk 'length > 80 {count++} END {print count}' file.txt

# Count occurrences of pattern
awk '/pattern/ {count++} END {print count}' file.txt

# Count by condition
awk '$3 > 100 {count++} END {print count}' data.txt

# Average line length
awk '{total += length; count++} END {print total/count}' file.txt

# Statistics
awk '{
  chars += length($0);
  words += NF;
  lines++;
}
END {
  print "Lines:", lines;
  print "Words:", words;
  print "Characters:", chars;
}' file.txt

# Combining tools for complex counting

# Total word count across all files
cat *.txt | wc -w

# Count unique words
tr -s ' ' '\n' < file.txt | sort -u | wc -l

# Count code files by extension
find . -name "*.js" -o -name "*.ts" | wc -l

# Top 10 most common words
cat file.txt | tr -s ' ' '\n' | tr 'A-Z' 'a-z' | \
  sort | uniq -c | sort -rn | head -10

# Count log entries by hour
awk '{print $1}' access.log | cut -d: -f1 | sort | uniq -c

# Average words per line
awk '{words += NF; lines++} END {print words/lines}' file.txt

# Count lines with emails
grep -cE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' file.txt

# Count empty vs non-empty lines
wc -l file.txt && grep -cv "^$" file.txt

# Project statistics
find . -name "*.js" -exec cat {} \; | wc
find . -name "*.js" | wc -l

// SEO content validation
function validateSEOContent(content) {
  const stats = getTextStatistics(content);

  return {
    title: {
      length: content.title?.length || 0,
      valid: content.title?.length >= 30 && content.title?.length <= 60,
      recommendation: '30-60 characters for optimal SEO'
    },
    metaDescription: {
      length: content.description?.length || 0,
      valid: content.description?.length >= 120 && content.description?.length <= 160,
      recommendation: '120-160 characters for best results'
    },
    content: {
      wordCount: stats.words.total,
      valid: stats.words.total >= 300,
      recommendation: 'Minimum 300 words, 1500-2500 ideal for SEO',
      readability: fleschReadingEase(content.body),
      readabilityGrade: interpretReadability(fleschReadingEase(content.body))
    },
    headings: {
      h1Count: (content.body.match(/<h1>/g) || []).length,
      h1Valid: (content.body.match(/<h1>/g) || []).length === 1,
      h2Count: (content.body.match(/<h2>/g) || []).length,
      recommendation: 'One H1, multiple H2s for structure'
    }
  };
}

// Social media character limits
const LIMITS = {
  twitter: 280,
  facebook: 63206,
  instagram: 2200,
  linkedin: 3000,
  tiktok: 2200,
  youtube: 5000
};

function validateSocialPost(text, platform) {
  const stats = {
    characters: text.length,
    charactersNoSpaces: text.replace(/\s/g, '').length,
    words: (text.match(/\b[\w']+\b/g) || []).length,
    hashtags: (text.match(/#\w+/g) || []).length,
    mentions: (text.match(/@\w+/g) || []).length,
    urls: (text.match(/https?:\/\/\S+/g) || []).length
  };

  const limit = LIMITS[platform];
  const remaining = limit - stats.characters;

  return {
    ...stats,
    limit,
    remaining,
    valid: stats.characters <= limit,
    usage: (stats.characters / limit * 100).toFixed(1) + '%'
  };
}

// Twitter-specific (handles URL shortening)
function validateTweet(text) {
  let adjusted = text;

  // Twitter shortens all URLs to 23 characters
  adjusted = adjusted.replace(/https?:\/\/\S+/g, 'x'.repeat(23));

  const stats = validateSocialPost(adjusted, 'twitter');
  stats.note = 'URLs count as 23 characters each';

  return stats;
}

// Code metrics and analysis
function analyzeCodeFile(code, language = 'javascript') {
  const lines = code.split(/\r?\n/);

  const metrics = {
    total: lines.length,
    code: 0,
    comments: 0,
    blank: 0,
    complexity: 0
  };

  let inBlockComment = false;

  for (const line of lines) {
    const trimmed = line.trim();

    if (trimmed.length === 0) {
      metrics.blank++;
      continue;
    }

    // Block comments
    if (trimmed.startsWith('/*')) inBlockComment = true;
    if (inBlockComment) {
      metrics.comments++;
      if (trimmed.includes('*/')) inBlockComment = false;
      continue;
    }

    // Single-line comments
    if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
      metrics.comments++;
      continue;
    }

    metrics.code++;

    // Cyclomatic complexity indicators
    if (/\b(if|else|while|for|case|catch)\b/.test(trimmed)) {
      metrics.complexity++;
    }
  }

  return {
    ...metrics,
    codeToCommentRatio: metrics.code / (metrics.comments || 1),
    commentPercentage: (metrics.comments / metrics.total * 100).toFixed(1) + '%',
    complexity: metrics.complexity + 1 // Base complexity
  };
}

// Document format validation
function validateDocument(content, requirements) {
  const stats = getTextStatistics(content);

  const validation = {
    valid: true,
    errors: [],
    warnings: []
  };

  // Word count requirements
  if (requirements.minWords && stats.words.total < requirements.minWords) {
    validation.valid = false;
    validation.errors.push(
      `Document too short: ${stats.words.total} words (minimum: ${requirements.minWords})`
    );
  }

  if (requirements.maxWords && stats.words.total > requirements.maxWords) {
    validation.valid = false;
    validation.errors.push(
      `Document too long: ${stats.words.total} words (maximum: ${requirements.maxWords})`
    );
  }

  // Reading level
  if (requirements.maxGradeLevel) {
    const grade = fleschKincaidGrade(content);
    if (grade > requirements.maxGradeLevel) {
      validation.warnings.push(
        `Reading level too high: Grade ${grade.toFixed(1)} (max: ${requirements.maxGradeLevel})`
      );
    }
  }

  // Average sentence length
  if (requirements.maxSentenceLength) {
    const avgSentence = stats.sentences.average;
    if (avgSentence > requirements.maxSentenceLength) {
      validation.warnings.push(
        `Average sentence too long: ${avgSentence.toFixed(1)} words`
      );
    }
  }

  return validation;
}

// Handle edge cases in counting
function robustCount(text) {
  // Handle null/undefined
  if (!text) {
    return { characters: 0, words: 0, lines: 0 };
  }

  // Handle non-string input
  if (typeof text !== 'string') {
    text = String(text);
  }

  // Handle empty string
  if (text.length === 0) {
    return { characters: 0, words: 0, lines: 0 };
  }

  // Handle only whitespace
  if (/^\s*$/.test(text)) {
    return {
      characters: text.length,
      words: 0,
      lines: text.split(/\r?\n/).length
    };
  }

  // Normal counting
  return {
    characters: text.length,
    words: (text.match(/\b[\w']+\b/g) || []).length,
    lines: text.split(/\r?\n/).length
  };
}

// Test edge cases
console.log(robustCount(null));         // All zeros
console.log(robustCount(''));           // All zeros
console.log(robustCount('   \n  '));   // Chars but no words
console.log(robustCount(123));          // Converts to string

// Validate input before counting
function safeCount(input) {
  try {
    // Type validation
    if (input === null || input === undefined) {
      throw new Error('Input cannot be null or undefined');
    }

    // Convert to string if needed
    const text = typeof input === 'string' ? input : String(input);

    // Size validation (prevent processing huge strings)
    const MAX_LENGTH = 10_000_000; // 10 million characters
    if (text.length > MAX_LENGTH) {
      throw new Error(`Input too large: ${text.length} characters (max: ${MAX_LENGTH})`);
    }

    // Perform counting
    return {
      success: true,
      data: {
        characters: text.length,
        words: (text.match(/\b[\w']+\b/g) || []).length,
        lines: text.split(/\r?\n/).length
      }
    };

  } catch (error) {
    return {
      success: false,
      error: error.message
    };
  }
}

// Usage
const result = safeCount(userInput);
if (result.success) {
  console.log('Stats:', result.data);
} else {
  console.error('Error:', result.error);
}