Calculate text width with JavaScript

Calculate text width with JavaScript

I’d like to use JavaScript to calculate the width of a string. Is this possible without having to use a monospace typeface?
If it’s not built-in, my only idea is to create a table of widths for each character, but this is pretty unreasonable especially supporting Unicode and different type sizes (and all browsers for that matter).


Solution 1:

Create a DIV styled with the following styles. In your JavaScript, set the font size and attributes that you are trying to measure, put your string in the DIV, then read the current width and height of the DIV. It will stretch to fit the contents and the size will be within a few pixels of the string rendered size.

var fontSize = 12;
var test = document.getElementById("Test"); = fontSize;
var height = (test.clientHeight + 1) + "px";
var width = (test.clientWidth + 1) + "px"

console.log(height, width);
    position: absolute;
    visibility: hidden;
    height: auto;
    width: auto;
    white-space: nowrap; /* Thanks to Herb Caudill comment */
<div id="Test">

Solution 2:

In HTML 5, you can just use the Canvas.measureText method (further explanation here).

Try this fiddle:

 * Uses canvas.measureText to compute and return the width of the given text of given font in pixels.
 * @param {String} text The text to be rendered.
 * @param {String} font The css font descriptor that text is to be rendered with (e.g. "bold 14px verdana").
 * @see
function getTextWidth(text, font) {
    // re-use canvas object for better performance
    var canvas = getTextWidth.canvas || (getTextWidth.canvas = document.createElement("canvas"));
    var context = canvas.getContext("2d");
    context.font = font;
    var metrics = context.measureText(text);
    return metrics.width;

console.log(getTextWidth("hello there!", "bold 12pt arial"));  // close to 86

This fiddle compares this Canvas method to a variation of Bob Monteverde’s DOM-based method, so you can analyze and compare accuracy of the results.

There are several advantages to this approach, including:

  • More concise and safer than the other (DOM-based) methods because it does not change global state, such as your DOM.
  • Further customization is possible by modifying more canvas text properties, such as textAlign and textBaseline.

NOTE: When you add the text to your DOM, remember to also take account of padding, margin and border.

NOTE 2: On some browsers, this method yields sub-pixel accuracy (result is a floating point number), on others it does not (result is only an int). You might want to run Math.floor (or Math.ceil) on the result, to avoid inconsistencies. Since the DOM-based method is never sub-pixel accurate, this method has even higher precision than the other methods here.

According to this jsperf (thanks to the contributors in comments), the Canvas method and the DOM-based method are about equally fast, if caching is added to the DOM-based method and you are not using Firefox. In Firefox, for some reason, this Canvas method is much much faster than the DOM-based method (as of September 2014).

Solution 3:

Here’s one I whipped together without example. It looks like we are all on the same page.

String.prototype.width = function(font) {
  var f = font || '12px arial',
      o = $('<div></div>')
            .css({'position': 'absolute', 'float': 'left', 'white-space': 'nowrap', 'visibility': 'hidden', 'font': f})
      w = o.width();


  return w;

Using it is simple: "a string".width()

**Added white-space: nowrap so strings with width larger than the window width can be calculated.

Solution 4:


(function($) {

 $.textMetrics = function(el) {

  var h = 0, w = 0;

  var div = document.createElement('div');
   position: 'absolute',
   left: -1000,
   top: -1000,
   display: 'none'

  var styles = ['font-size','font-style', 'font-weight', 'font-family','line-height', 'text-transform', 'letter-spacing'];
  $(styles).each(function() {
   var s = this.toString();
   $(div).css(s, $(el).css(s));

  h = $(div).outerHeight();
  w = $(div).outerWidth();


  var ret = {
   height: h,
   width: w

  return ret;


Solution 5:

This works for me…

// Handy JavaScript to measure the size taken to render the supplied text;
// you can supply additional style information too if you have it.

function measureText(pText, pFontSize, pStyle) {
    var lDiv = document.createElement('div');


    if (pStyle != null) { = pStyle;
    } = "" + pFontSize + "px"; = "absolute"; = -1000; = -1000;

    lDiv.innerHTML = pText;

    var lResult = {
        width: lDiv.clientWidth,
        height: lDiv.clientHeight

    lDiv = null;

    return lResult;

Solution 6:

The ExtJS javascript library has a great class called Ext.util.TextMetrics that “provides precise pixel measurements for blocks of text so that you can determine exactly how high and wide, in pixels, a given block of text will be”. You can either use it directly or view its source to code to see how this is done.