Number of Lines Validation Regular Expression

Validating the number of lines in text is essential for forms, comments, descriptions, and multi-line input fields. Regular expressions can enforce minimum, maximum, or specific line count ranges to ensure content meets formatting requirements. This is particularly useful for limiting feedback forms, code snippets, addresses, and other structured text inputs. For validating character length of text, see the text length validation article.

Platform Considerations

Line counting can vary across platforms due to different newline conventions: Unix/Linux uses \n (LF), Windows uses \r\n (CRLF), and classic Mac OS used \r (CR). Modern applications typically normalize to \n. For cross-platform compatibility, consider preprocessing text or using string split methods that handle multiple newline formats. The regex patterns shown here assume normalized \n line endings.

Line Range Validation (5-20 lines)

This pattern validates that text contains between 5 and 20 lines, inclusive. This is useful for multi-line input fields like comments, descriptions, or addresses where you want to enforce both minimum and maximum line constraints.

^(?:[^\n]*\n){4,19}[^\n]*$

Explanation

^ - Start of the string.
(?:[^\n]*\n) - Non-capturing group that matches any content except newline, followed by a newline character. This represents one complete line.
{4,19} - Quantifier requiring 4 to 19 occurrences of the preceding group (matching lines 1-19, with the final line matched separately).
[^\n]* - Matches the final line, which may not end with a newline character.
$ - End of the string.

Note: The pattern matches {4,19} newlines plus one final line = 5-20 total lines. For N lines, use {N-1} as the upper bound in the quantifier.

Implementation

const lineRangeRegex = /^(?:[^\n]*\n){4,19}[^\n]*$/;
const isValidLineCount = (text) => lineRangeRegex.test(text);

// For configurable min/max:
function validateLineCount(text, min, max) {
  const lines = text.split('\n').length;
  return lines >= min && lines <= max;
}

import re

def is_valid_line_count(text):
  lineRangeRegex = r"^(?:[^\n]*\n){4,19}[^\n]*$"
  return re.match(lineRangeRegex, text, re.MULTILINE) is not None

# For configurable min/max:
def validate_line_count(text, min_lines, max_lines):
  lines = text.count('\n') + 1
  return min_lines <= lines <= max_lines

use regex::Regex;

fn is_valid_line_count(text: &str) -> bool {
  let line_range_regex = Regex::new(r"^(?:[^\n]*\n){4,19}[^\n]*$")
    .expect("Could not parse line count validation regex");
  line_range_regex.is_match(text)
}

// For configurable min/max:
fn validate_line_count(text: &str, min: usize, max: usize) -> bool {
  let lines = text.matches('\n').count() + 1;
  lines >= min && lines <= max
}

package main

import (
  "regexp"
  "strings"
)

func isValidLineCount(text string) bool {
  lineRangeRegex := "^(?:[^\n]*\n){4,19}[^\n]*$"
  re := regexp.MustCompile(lineRangeRegex)
  return re.MatchString(text)
}

// For configurable min/max:
func validateLineCount(text string, min int, max int) bool {
  lines := strings.Count(text, "\n") + 1
  return lines >= min && lines <= max
}

import Foundation

func isValidLineCount(_ text: String) -> Bool {
  let lineRangeRegex = "^(?:[^\n]*\n){4,19}[^\n]*$"
  return NSPredicate(format: "SELF MATCHES %@", lineRangeRegex).evaluate(with: text)
}

// For configurable min/max:
func validateLineCount(_ text: String, min: Int, max: Int) -> Bool {
  let lines = text.components(separatedBy: "\n").count
  return lines >= min && lines <= max
}

using System;
using System.Text.RegularExpressions;
using System.Linq;

class Application {
  static bool IsValidLineCount(string text) {
    string lineRangeRegex = "^(?:[^\n]*\n){4,19}[^\n]*$";
    return Regex.IsMatch(text, lineRangeRegex);
  }
  
  // For configurable min/max:
  static bool ValidateLineCount(string text, int min, int max) {
    int lines = text.Split('\n').Length;
    return lines >= min && lines <= max;
  }
}

import java.util.regex.*;

public class Application {
  public static boolean isValidLineCount(String text) {
    String lineRangeRegex = "^(?:[^\n]*\n){4,19}[^\n]*$";
    Pattern pattern = Pattern.compile(lineRangeRegex);
    Matcher matcher = pattern.matcher(text);
    return matcher.matches();
  }
  
  // For configurable min/max:
  public static boolean validateLineCount(String text, int min, int max) {
    int lines = text.split("\n").length;
    return lines >= min && lines <= max;
  }
}

<?php
function isValidLineCount($text) {
  $lineRangeRegex = "^(?:[^\n]*\n){4,19}[^\n]*$";
  return preg_match("/" . $lineRangeRegex . "/", $text);
}

// For configurable min/max:
function validateLineCount($text, $min, $max) {
  $lines = substr_count($text, "\n") + 1;
  return $lines >= $min && $lines <= $max;
}
?>

Test Cases

Test Case	Valid
5 lines (minimum boundary)
10 lines (middle range)
20 lines (maximum boundary)
1 line (below minimum)
4 lines (below minimum)
21 lines (above maximum)
Empty string
5 lines with empty line

Minimum Line Validation (5+ lines)

This pattern validates that text has a minimum of 5 lines with no upper limit. This is useful for fields like detailed descriptions, feedback forms, or code snippets where you want to ensure sufficient content without limiting maximum length.

^(?:[^\n]*\n){4,}[^\n]*$

Explanation

^ - Start of the string.
(?:[^\n]*\n) - Non-capturing group matching any content followed by a newline (one complete line).
{4,} - Quantifier requiring at least 4 occurrences with no upper limit (matching lines 1-4+, with the final line matched separately).
[^\n]* - Matches the final line.
$ - End of the string.

Implementation

const minLinesRegex = /^(?:[^\n]*\n){4,}[^\n]*$/;
const hasMinimumLines = (text) => minLinesRegex.test(text);

import re

def has_minimum_lines(text):
  minLinesRegex = r"^(?:[^\n]*\n){4,}[^\n]*$"
  return re.match(minLinesRegex, text, re.MULTILINE) is not None

use regex::Regex;

fn has_minimum_lines(text: &str) -> bool {
  let min_lines_regex = Regex::new(r"^(?:[^\n]*\n){4,}[^\n]*$")
    .expect("Could not parse minimum lines regex");
  min_lines_regex.is_match(text)
}

package main

import (
  "regexp"
)

func hasMinimumLines(text string) bool {
  minLinesRegex := "^(?:[^\n]*\n){4,}[^\n]*$"
  re := regexp.MustCompile(minLinesRegex)
  return re.MatchString(text)
}

import Foundation

func hasMinimumLines(_ text: String) -> Bool {
  let minLinesRegex = "^(?:[^\n]*\n){4,}[^\n]*$"
  return NSPredicate(format: "SELF MATCHES %@", minLinesRegex).evaluate(with: text)
}

using System;
using System.Text.RegularExpressions;

class Application {
  static bool HasMinimumLines(string text) {
    string minLinesRegex = "^(?:[^\n]*\n){4,}[^\n]*$";
    return Regex.IsMatch(text, minLinesRegex);
  }
}

import java.util.regex.*;

public class Application {
  public static boolean hasMinimumLines(String text) {
    String minLinesRegex = "^(?:[^\n]*\n){4,}[^\n]*$";
    Pattern pattern = Pattern.compile(minLinesRegex);
    Matcher matcher = pattern.matcher(text);
    return matcher.matches();
  }
}

<?php
function hasMinimumLines($text) {
  $minLinesRegex = "^(?:[^\n]*\n){4,}[^\n]*$";
  return preg_match("/" . $minLinesRegex . "/", $text);
}
?>

Test Cases

Test Case	Valid
5 lines (minimum boundary)
10 lines
26 lines (well above minimum)
4 lines (below minimum)
1 line
Empty string
3 lines

Maximum Line Validation (0-20 lines)

This pattern validates that text does not exceed 20 lines. It allows any line count from 0 (empty string) up to 20 lines. This is useful for fields like brief comments, summaries, or short descriptions where you want to limit verbosity.

^(?:[^\n]*\n){0,19}[^\n]*$

Explanation

^ - Start of the string.
(?:[^\n]*\n) - Non-capturing group matching any content followed by a newline.
{0,19} - Quantifier allowing 0 to 19 occurrences of the preceding group (matching 0-19 newlines, with the final line matched separately).
[^\n]* - Matches the final line (which could be empty).
$ - End of the string.

Implementation

const maxLinesRegex = /^(?:[^\n]*\n){0,19}[^\n]*$/;
const hasMaximumLines = (text) => maxLinesRegex.test(text);

import re

def has_maximum_lines(text):
  maxLinesRegex = r"^(?:[^\n]*\n){0,19}[^\n]*$"
  return re.match(maxLinesRegex, text, re.MULTILINE) is not None

use regex::Regex;

fn has_maximum_lines(text: &str) -> bool {
  let max_lines_regex = Regex::new(r"^(?:[^\n]*\n){0,19}[^\n]*$")
    .expect("Could not parse maximum lines regex");
  max_lines_regex.is_match(text)
}

package main

import (
  "regexp"
)

func hasMaximumLines(text string) bool {
  maxLinesRegex := "^(?:[^\n]*\n){0,19}[^\n]*$"
  re := regexp.MustCompile(maxLinesRegex)
  return re.MatchString(text)
}

import Foundation

func hasMaximumLines(_ text: String) -> Bool {
  let maxLinesRegex = "^(?:[^\n]*\n){0,19}[^\n]*$"
  return NSPredicate(format: "SELF MATCHES %@", maxLinesRegex).evaluate(with: text)
}

using System;
using System.Text.RegularExpressions;

class Application {
  static bool HasMaximumLines(string text) {
    string maxLinesRegex = "^(?:[^\n]*\n){0,19}[^\n]*$";
    return Regex.IsMatch(text, maxLinesRegex);
  }
}

import java.util.regex.*;

public class Application {
  public static boolean hasMaximumLines(String text) {
    String maxLinesRegex = "^(?:[^\n]*\n){0,19}[^\n]*$";
    Pattern pattern = Pattern.compile(maxLinesRegex);
    Matcher matcher = pattern.matcher(text);
    return matcher.matches();
  }
}

<?php
function hasMaximumLines($text) {
  $maxLinesRegex = "^(?:[^\n]*\n){0,19}[^\n]*$";
  return preg_match("/" . $maxLinesRegex . "/", $text);
}
?>

Test Cases

Test Case	Valid
Empty string
1 line
5 lines
20 lines (maximum boundary)
21 lines (above maximum)
26 lines (well above maximum)

Alternative: String Split Approach

For dynamic or complex line count validation, using string manipulation methods is often more practical than regex. This approach provides better readability, easier maintenance, and handles edge cases more reliably. The code examples above include both regex and programmatic approaches for flexibility.