How to Count Lines in JavaScript: 6 Methods with Performance Benchmarks

You paste 50,000 lines of log output into a string variable. You call .split('\n').length. You get 50,001.

Why?

That off-by-one result is the most common bug when developers count lines in JavaScript. A trailing newline creates an extra empty array item, Windows files use \r\n instead of just \n, and large files can crash a process if you read everything into memory before counting. The right answer depends on where the text lives and how large it is.

The practical challenge is that "count lines in JavaScript" can mean at least six different jobs. You might count lines in JavaScript strings, uploaded browser files, Node.js files, streams, textarea input, or source code. Each case has a different failure mode.

This guide covers six practical ways to count lines in JavaScript:

• Method 1: Count lines in a JavaScript string
• Method 2: Count lines in a browser file upload
• Method 3: Count lines in Node.js small files
• Method 4: Count lines in large files with Node.js streams
• Method 5: Count lines in React, Vue, and textarea inputs
• Method 6: Count non-empty lines and code lines

If you came from Python, the edge cases are similar but the APIs are different. The companion Python line counting guide covers splitlines(), file iteration, and wc -l comparisons in detail.

30-Second Decision Guide

Use this guide before choosing code. The fastest way to count lines in JavaScript is not always the best way; the best method is the one that matches your input size and runtime.

Here is the short version: use string counting for values already in memory, browser streams for large uploads, Node.js streams for server-side files, and a purpose-built code counter when comments and blank lines matter. If you only need to count lines in JavaScript examples once, the browser-based Line Counter tool is the no-code path.

Method 1: Count Lines in a JavaScript String

The simplest answer to JavaScript count lines in string is str.split('\n').length.

// Basic method
function countLines(str) {
  return str.split('\n').length;
}

console.log(countLines("line1\nline2")); // 2

That is fine for a quick demo, but it is not always the result users expect.

function countLines(str) {
  return str.split('\n').length;
}

console.log(countLines("line1\nline2\n")); // 3, not 2

The split operation sees two newline separators and produces three array items: "line1", "line2", and "". That empty final string is the off-by-one bug.

Use this corrected version when a trailing newline should not count as an extra logical line:

function countLinesAccurate(str) {
  if (str.length === 0) return 0;

  const lines = str.split('\n');
  return lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
}

console.log(countLinesAccurate("line1\nline2\n")); // 2

For cross-platform input, count newline sequences directly:

function countLinesCrossPlatform(str) {
  if (str.length === 0) return 0;

  const newlineMatches = str.match(/\r\n|\r|\n/g) || [];
  const endsWithNewline = /\r\n|\r|\n$/.test(str);

  return newlineMatches.length + (endsWithNewline ? 0 : 1);
}

console.log(countLinesCrossPlatform("a\r\nb")); // 2
console.log(countLinesCrossPlatform("a\nb\n")); // 2
console.log(countLinesCrossPlatform("")); // 0

If you only need to support Unix-style \n, this concise version is common:

const countLines = (str) => (str ? (str.match(/\n/g) || []).length + 1 : 0);

That concise version is useful, but it does not correct the trailing-newline interpretation. For user-facing counters, prefer the explicit countLinesCrossPlatform version.

For strings under 10MB, split('\n') and a regex counter usually run in a few milliseconds on modern hardware. For strings over 100MB, a regex or loop that counts newline characters can use less memory because it does not create an array containing every line. That matters when performance is part of the requirement.

Method 2: Count Lines in a File (Browser / FileReader API)

For browser file inputs under about 50MB, FileReader is the simplest option:

function countLinesAccurate(str) {
  if (str.length === 0) return 0;

  const newlineMatches = str.match(/\r\n|\r|\n/g) || [];
  const endsWithNewline = /\r\n|\r|\n$/.test(str);

  return newlineMatches.length + (endsWithNewline ? 0 : 1);
}

function countLinesInFile(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();

    reader.onload = (event) => {
      const text = event.target.result;
      resolve(countLinesAccurate(String(text)));
    };

    reader.onerror = () => reject(reader.error);
    reader.readAsText(file);
  });
}

document.getElementById('fileInput').addEventListener('change', async (event) => {
  try {
    const file = event.target.files[0];
    if (!file) return;

    const count = await countLinesInFile(file);
    console.log(`Line count: ${count}`);
  } catch (error) {
    console.error('Could not count file lines:', error);
  }
});

For larger browser files, use File.stream() with TextDecoder. This avoids storing the entire file as one giant string.

async function countLinesStream(file) {
  const reader = file.stream().getReader();
  const decoder = new TextDecoder();

  let lineCount = 0;
  let remainder = '';
  let lastChunkEndedWithNewline = false;

  while (true) {
    const { done, value } = await reader.read();

    if (done) {
      if (remainder.length > 0) {
        lineCount++;
      } else if (lineCount > 0 && lastChunkEndedWithNewline) {
        // Do not add an extra line for a trailing newline.
      }
      break;
    }

    const chunk = remainder + decoder.decode(value, { stream: true });
    const normalized = chunk.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
    const lines = normalized.split('\n');

    remainder = lines.pop() ?? '';
    lineCount += lines.length;
    lastChunkEndedWithNewline = normalized.endsWith('\n');
  }

  return lineCount;
}

Use FileReader when the file is small and you want simple code. Use file.stream() when the file is large, when you need a progress indicator, or when browser memory pressure matters. Both approaches keep the text local to the user's device.

Method 3: Count Lines in Node.js (Small Files)

For small files, fs.promises.readFile is readable and reliable.

const fs = require('node:fs/promises');

function countLinesAccurate(str) {
  if (str.length === 0) return 0;

  const newlineMatches = str.match(/\r\n|\r|\n/g) || [];
  const endsWithNewline = /\r\n|\r|\n$/.test(str);

  return newlineMatches.length + (endsWithNewline ? 0 : 1);
}

async function countLinesAsync(filePath) {
  const content = await fs.readFile(filePath, 'utf8');
  return countLinesAccurate(content);
}

async function main() {
  try {
    const count = await countLinesAsync('./data.txt');
    console.log(`Lines: ${count}`);
  } catch (error) {
    console.error('Could not count lines:', error);
    process.exitCode = 1;
  }
}

main();

Synchronous code is acceptable for quick one-off scripts:

const fs = require('node:fs');

function countLinesSync(filePath) {
  const content = fs.readFileSync(filePath, 'utf8');
  return countLinesAccurate(content);
}

console.log(countLinesSync('./data.txt'));

The rule is simple: fs.readFile is convenient, but it reads the entire file into memory. Use it for small known files. Do not use it as a general answer to count lines in file Node.js when log files, exports, or generated data may be large. If you want to count lines in JavaScript automation that runs on unknown inputs, streams are the safer default.

Method 4: Count Lines in Large Files with Node.js Streams

This is the most important section if you care about count lines JavaScript performance. A full read can look faster on tiny files, but it becomes fragile as file sizes grow.

Method 4A: Node.js readline count lines

readline is the official, readable streaming API for line-by-line processing. The crlfDelay: Infinity option matters because it treats Windows \r\n as one line break.

const fs = require('node:fs');
const readline = require('node:readline');

function countLinesReadline(filePath) {
  return new Promise((resolve, reject) => {
    let lineCount = 0;

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

    rl.on('line', () => {
      lineCount++;
    });

    rl.on('close', () => {
      resolve(lineCount);
    });

    rl.on('error', reject);
  });
}

async function main() {
  try {
    const count = await countLinesReadline('./large.log');
    console.log(`Lines: ${count}`);
  } catch (error) {
    console.error(error);
    process.exitCode = 1;
  }
}

main();

Use Node.js readline count lines code when you may later need to inspect each line, filter it, or parse fields while counting.

Method 4B: Buffer chunk scan

If you only need the count, scanning raw bytes is faster because it avoids creating a JavaScript string for every line.

const fs = require('node:fs');

function countLinesBuffer(filePath) {
  return new Promise((resolve, reject) => {
    let newlineCount = 0;
    let sawAnyByte = false;
    let lastByte = null;
    const NEWLINE = 10; // '\n'

    const stream = fs.createReadStream(filePath, {
      highWaterMark: 64 * 1024,
    });

    stream.on('data', (chunk) => {
      sawAnyByte = true;

      for (let i = 0; i < chunk.length; i++) {
        if (chunk[i] === NEWLINE) {
          newlineCount++;
        }
      }

      lastByte = chunk[chunk.length - 1];
    });

    stream.on('end', () => {
      if (!sawAnyByte) {
        resolve(0);
        return;
      }

      // wc -l counts newline bytes. Most text editors count the final
      // unterminated row as a line too, so add 1 when the file does not
      // end with '\n'.
      resolve(lastByte === NEWLINE ? newlineCount : newlineCount + 1);
    });

    stream.on('error', reject);
  });
}

This scanner handles the final-line boundary explicitly. If a file has a\nb with no newline after b, it returns 2. If the file is a\nb\n, it returns 2 rather than 3.

Benchmark: JavaScript line counting performance

These benchmark values are directional measurements for line-oriented ASCII text on Node.js 20 LTS, Apple M2 Pro, macOS, SSD storage, averaged across repeated local runs. Hardware, encoding, line length, storage, and antivirus indexing can change absolute timings. The stable lesson is the relative shape: full reads are simple, readline is scalable, and Buffer scanning is fastest for raw counts.

If you are on Linux or macOS and do not need JavaScript, wc -l is often faster still. The cross-platform command-line overview in the file line counting guide compares terminal options and GUI workflows.

Method 5: Count Lines in React, Vue, and Vanilla JS Textareas

React controlled input:

function countLinesAccurate(str) {
  if (str.length === 0) return 0;

  const newlineMatches = str.match(/\r\n|\r|\n/g) || [];
  const endsWithNewline = /\r\n|\r|\n$/.test(str);

  return newlineMatches.length + (endsWithNewline ? 0 : 1);
}

function LineCounterTextarea() {
  const [text, setText] = React.useState('');
  const lineCount = React.useMemo(() => countLinesAccurate(text), [text]);

  return (
    <div>
      <textarea
        value={text}
        onChange={(event) => setText(event.target.value)}
        rows={10}
      />
      <p>Lines: {lineCount}</p>
    </div>
  );
}

Vue 3 computed value:

import { computed, ref } from 'vue';

const text = ref('');

const lineCount = computed(() => {
  return countLinesAccurate(text.value);
});

Vanilla JavaScript:

const textarea = document.querySelector('textarea');
const counter = document.querySelector('#line-count');

textarea.addEventListener('input', () => {
  const lines = countLinesAccurate(textarea.value);
  counter.textContent = `Lines: ${lines}`;
});

Do not use textarea.rows for line counting. That attribute controls the visible height of the element. It does not tell you how many newline characters are in the value, and it does not account for soft wrapping caused by CSS width.

Method 6: Count Non-Empty Lines and Code Lines

Counting non-empty lines is straightforward:

function countNonEmptyLines(str) {
  return str
    .split(/\r\n|\r|\n/)
    .filter((line) => line.trim().length > 0)
    .length;
}

console.log(countNonEmptyLines("a\n\nb\n")); // 2

Counting lines of code is more subjective. This simple version excludes blank lines and obvious single-line comments:

function countCodeLines(str, language = 'js') {
  const lines = str.split(/\r\n|\r|\n/);
  const commentPatterns = {
    js: /^\s*(\/\/|\/\*|\*)/,
    ts: /^\s*(\/\/|\/\*|\*)/,
    python: /^\s*#/,
    css: /^\s*(\/\*|\*)/,
  };

  const pattern = commentPatterns[language] || commentPatterns.js;

  return lines.filter((line) => {
    const trimmed = line.trim();
    return trimmed.length > 0 && !pattern.test(trimmed);
  }).length;
}

To count a directory in Node.js:

const fs = require('node:fs/promises');
const path = require('node:path');

async function countLinesInDirectory(dirPath, extensions = ['.js', '.ts']) {
  const results = { total: 0, byFile: {} };

  async function walk(currentDir) {
    const entries = await fs.readdir(currentDir, { withFileTypes: true });

    for (const entry of entries) {
      const fullPath = path.join(currentDir, entry.name);

      if (entry.isDirectory()) {
        if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
          await walk(fullPath);
        }
        continue;
      }

      if (extensions.includes(path.extname(entry.name))) {
        const content = await fs.readFile(fullPath, 'utf8');
        const count = countNonEmptyLines(content);
        results.byFile[fullPath] = count;
        results.total += count;
      }
    }
  }

  await walk(dirPath);
  return results;
}

This is useful for small internal scripts. For a real codebase report, a dedicated source-code counter understands block comments, generated files, vendored folders, embedded languages, and language-specific syntax.

Method Comparison Table

This table is the quick reference version of the article.

If your goal is "just count this now," use the online line counter instead of writing utility code. If your goal is automation, pick the smallest implementation that still handles your largest expected input. That is the core rule when you count lines in JavaScript across both browser and Node.js projects.

Edge Cases You Should Test

Before shipping a line counter, test these cases explicitly. These are the cases that make "count lines in JavaScript" look trivial in a snippet but fragile in a real app.

The most important policy decision is whether a trailing newline creates a new logical line. Most text editors and user-facing tools say no. Some low-level tools, including wc -l, count newline bytes instead. State your policy in code comments when the behavior matters.

Complete Utility: Reusable JavaScript Line Counter

This small utility centralizes the string behavior so your browser, React, and Node.js small-file code all agree. It is a practical base when you need to count lines in JavaScript in more than one part of a codebase.

export function countLines(text, options = {}) {
  const {
    countTrailingNewline = false,
    ignoreEmpty = false,
  } = options;

  if (text.length === 0) return 0;

  const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
  let lines = normalized.split('\n');

  if (!countTrailingNewline && lines[lines.length - 1] === '') {
    lines = lines.slice(0, -1);
  }

  if (ignoreEmpty) {
    lines = lines.filter((line) => line.trim().length > 0);
  }

  return lines.length;
}

console.log(countLines("a\nb\n")); // 2
console.log(countLines("a\nb\n", { countTrailingNewline: true })); // 3
console.log(countLines("a\n\nb", { ignoreEmpty: true })); // 2

This is the best default answer for JavaScript count lines in string when you control the codebase and want explicit behavior.

FAQ

Why does split('\n').length return one extra line?

Because split() returns the text before and after each separator. A trailing separator has nothing after it, so JavaScript returns an empty string as the final array item. "hello\n".split('\n') becomes ["hello", ""], which has length 2.

How do I count lines in a .js file in Node.js?

For a small .js file, use fs.promises.readFile(filePath, 'utf8') and the accurate string counter above. For large files, use readline.createInterface({ input: fs.createReadStream(filePath), crlfDelay: Infinity }).

What is the fastest way to count lines in a large file?

The Buffer chunk scan is usually the fastest JavaScript method because it counts raw newline bytes. Use it when you only need a number. Use readline when you also need to inspect or transform each line.

How do I count lines without counting empty lines?

Split on cross-platform newline sequences and filter:

const count = text
  .split(/\r\n|\r|\n/)
  .filter((line) => line.trim().length > 0)
  .length;

Does \r\n count as one line or two?

It should count as one line ending. \r\n is the Windows newline sequence. In Node.js streams, crlfDelay: Infinity tells readline to treat the sequence as a single line break.

How do I count lines in a string in the browser?

Use the same string counter shown in Method 1. JavaScript string methods behave the same in modern browsers and Node.js for this task.

How do I count lines in React?

Keep the textarea value in state, then derive the count from that value. Count \n characters in the value, not visual rows created by wrapping.

Related Guides and Tools

• TypeScript file line counting for readFileSync typing, readline, and stream-safe Node.js patterns.
• Python line counting guide for Python file, string, directory, and CLI methods.
• Java file line counting for JVM services, Spring Boot uploads, and large-file benchmarks.
• C# line counting for File.ReadLines, StreamReader, and async .NET services.
• PHP line counting for file(), fgets, SplFileObject, and WordPress upload processing.
• SQL row counting for database counts, Prisma, SQLAlchemy, and fast estimates.
• VS Code line counting guide for editor status bar, selection, and project-wide methods.
• Cross-platform file line counting guide for terminal, Windows, macOS, Linux, and wc -l workflows.
• Online line counter for a no-code count of pasted text and uploaded files.
• Line Counter tool for the main browser-based line, word, character, and paragraph counter.

Don't Want to Write Code for a Quick Count?

If you just need to count lines in a file or string right now without writing a single line of code, paste it into the Line Counter tool. It handles text, code files, and uploads in the browser, with line, word, character, paragraph, and reading-time stats.

The code above is the right choice when you are building the behavior into an app or script. For one-off counting, the tool is faster than opening an editor, creating a file, and debugging newline edge cases.