Flot 统计图表中文 API 文档 - 文章教程

Flot 统计图表中文 API 文档

发布于 2017-07-12 字数 59456 浏览 2046 评论 0


Consider a call to the plot function:


var plot = $.plot(placeholder, data, options)

The placeholder is a jQuery object or DOM element or jQuery expression that the plot will be put into. This placeholder needs to have its width and height set as explained in the README (go read that now if you haven’t, it’s short). The plot will modify some properties of the placeholder so it’s recommended you simply pass in a div that you don’t use for anything else. Make sure you check any fancy styling you apply to the div, e.g. background images have been reported to be a problem on IE 7.


The format of the data is documented below, as is the available options. The “plot” object returned has some methods you can call. These are documented separately below.


Note that in general Flot gives no guarantees if you change any of the objects you pass in to the plot function or get out of it since they’re not necessarily deep-copied.



The data is an array of data series:


[ series1, series2, ... ]

A series can either be raw data or an object with properties. The raw data format is an array of points:


[ [x1, y1], [x2, y2], ... ]


[ [1, 3], [2, 14.01], [3.5, 3.14] ]

Note that to simplify the internal logic in Flot both the x and y values must be numbers (even if specifying time series, see below for how to do this). This is a common problem because you might retrieve data from the database and serialize them directly to JSON without noticing the wrong type. If you’re getting mysterious errors, double check that you’re inputting numbers and not strings.


If a null is specified as a point or if one of the coordinates is null or couldn’t be converted to a number, the point is ignored when drawing. As a special case, a null value for lines is interpreted as a line segment end, i.e. the points before and after the null value are not connected.

如果坐标为值为空 ,或者其中的一个坐标值为空,或者不是数字,或者说不能转换为数字,那么这个节点将被忽略,并且该节点前后的2个节点之间不会使用直线来连接。

Lines and points take two coordinates. For bars, you can specify a third coordinate which is the bottom of the bar (defaults to 0).


The format of a single series object is as follows:


    color: color or number //颜色
    data: rawdata //数据
    label: string //曲线名称
    lines: specific lines options //折线图坐标参数
    bars: specific bars options //直方图坐标参数
    points: specific points options //散点图坐标参数
    xaxis: 1 or 2 //使用哪一条X轴,如果某条数轴没有被任何一条曲线使用,该数轴不会在图表上出现
    yaxis: 1 or 2 //使用哪一条Y轴
    clickable: boolean //允许监听鼠标点击事件
    hoverable: boolean //允许监听鼠标悬停事件
    shadowSize: number //曲线阴影

You don’t have to specify any of them except the data, the rest are options that will get default values. Typically you’d only specify label and data, like this:

一般情况下你无须设置每一个参数, 你只需要设置其中几个特定的参数即可,其他参数会使用默认值。例如:

    label: "y = 3",
    data: [[0, 3], [10, 3]]

The label is used for the legend, if you don’t specify one, the series will not show up in the legend.


If you don’t specify color, the series will get a color from the auto-generated colors. The color is either a CSS color specification (like “rgb(255, 100, 123)”) or an integer that specifies which of auto-generated colors to select, e.g. 0 will get color no. 0, etc.


The latter is mostly useful if you let the user add and remove series, in which case you can hard-code the color index to prevent the colors from jumping around between the series.


The “xaxis” and “yaxis” options specify which axis to use, specify 2 to get the secondary axis (x axis at top or y axis to the right). E.g., you can use this to make a dual axis plot by specifying { yaxis: 2 } for one data series.

xaxis” 和 “yaxis” 设置曲线使用的数轴(第二条X轴是顶部横轴,第二条Y轴是右边的纵轴),你可以使用这个属性制作双数轴曲线。

“clickable” and “hoverable” can be set to false to disable interactivity for specific series if interactivity is turned on in the plot, see below.

“clickable” 和 “hoverable”用于关闭该曲线的鼠标点击效果或鼠标悬停效果,具体说明看后面。

options中的”clickable” 或 “hoverable”设置为true时可以在某条曲线的data里设置”clickable” 或 “hoverable”为false,但options中设置为false时,不能在这里设置为true。

The rest of the options are all documented below as they are the same as the default options passed in via the options parameter in the plot commmand. When you specify them for a specific data series, they will override the default options for the plot for that data series.


Here’s a complete example of a simple data specification:


  { label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
  { label: "Bar", data: [ [11, 13], [19, 11], [30, -7] ] }


All options are completely optional. They are documented individually below, to change them you just specify them in an object, e.g.


var options = {
    series: {
        lines: { show: true },
        points: { show: true }
$.plot(placeholder, data, options);


legend: {
    show: boolean
    labelFormatter: null or (fn: string, series object -> string)
    labelBoxBorderColor: color
    noColumns: number
    position: "ne" or "nw" or "se" or "sw"
    margin: number of pixels or [x margin, y margin]
    backgroundColor: null or color
    backgroundOpacity: number between 0 and 1
    container: null or jQuery object/DOM element/jQuery expression

The legend is generated as a table with the data series labels and small label boxes with the color of the series. If you want to format the labels in some way, e.g. make them to links, you can pass in a function for “labelFormatter”. Here’s an example that makes them clickable:

legend 用于生成图表标题,图表标题以表格的方式显示在曲线图上,内容包括每条曲线的名称及其对应颜色,如果你想定制图表标题的格式,比如做成超链接,你可以在”labelFormatter”项使用函数来定制,下面的例子把图表标题做成链接:

labelFormatter: function(label, series) {
    // series is the series object for the label //series是名称为label的曲线的数据对象
    return '<a href="#' + label + '">' + label + '</a>';

“noColumns” is the number of columns to divide the legend table into.

“noColumns” 用于设置legend表格的列数

“position” specifies the overall placement of the legend within the plot (top-right, top-left, etc.) and margin the distance to the plot edge (this can be either a number or an array of two numbers like [x, y]). “backgroundColor” and “backgroundOpacity” specifies the background. The default is a partly transparent auto-detected background.

  • position:用于指定 legend 在曲线图内的位置,”ne”东北角,”se”东南 , “nw”西北 , “sw”西南
  • margin: 设置 legend 与曲线图边框的距离,可以是x y轴偏移量的数值对[x,y]也可以是单个数字,单个数字值表示相对 x, y 轴的偏移量使用相同的值采用哪条X轴和Y轴作为参照物取决于position的值
  • backgroundColor: 设置legend的背景颜色
  • backgroundOpacity: 设置legend背景的透明度

If you want the legend to appear somewhere else in the DOM, you can specify “container” as a jQuery object/expression to put the legend table into. The “position” and “margin” etc. options will then be ignored. Note that Flot will overwrite the contents of the container.

如果你想把legend放在其他DOM元素内,可以为container设定一个值,container的值可以是jQuery对象或表达式,例如:container: $(“#showChartLegend”),把标题显示在id为showChartLegend的div或其他容器类标签内,container为legend指定容器后,”position” 和 “margin” 等与图表相关的位置属性会被忽略,另外请注意,container指定的容器内容会被覆盖掉。


xaxis, yaxis, x2axis, y2axis: {

mode: null or “time” //数轴是否为时间模式

min: null or number //数轴最小值

max: null or number //数轴最大值

autoscaleMargin: null or number //按百分比为数轴延长一小段来缩放曲线以避免曲线最远的数据点出现在图表边框上




labelWidth: null or number

labelHeight: null or number

transform: null or fn: number -> number

inverseTransform: null or fn: number -> number

ticks: null or number or ticks array or (fn: range -> ticks array)

tickSize: number or array

minTickSize: number or array

tickFormatter: (fn: number, object -> string) or string

tickDecimals: null or number


All axes have the same kind of options. The “mode” option

determines how the data is interpreted, the default of null means as

decimal numbers. Use “time” for time series data, see the next section.


The options “min”/”max” are the precise minimum/maximum value on the

scale. If you don’t specify either of them, a value will automatically

be chosen based on the minimum/maximum data values.

“min”/”max” 设置数轴最大值和最小值,如果没有明确指定他们,将自动使用数据中的最小值和最大值

The “autoscaleMargin” is a bit esoteric: it’s the fraction of margin

that the scaling algorithm will add to avoid that the outermost points

ends up on the grid border. Note that this margin is only applied

when a min or max value is not explicitly set. If a margin is

specified, the plot will furthermore extend the axis end-point to the

nearest whole tick. The default value is “null” for the x axis and

0.02 for the y axis which seems appropriate for most cases.


“labelWidth” and “labelHeight” specifies a fixed size of the tick

labels in pixels. They’re useful in case you need to align several


“labelWidth” 和 “labelHeight” 用于设置数轴刻度标签的高宽,这个属性在你需要排列整齐几个图表的时候会派上用场。

“transform” and “inverseTransform” are callbacks you can put in to

change the way the data is drawn. You can design a function to

compress or expand certain parts of the axis non-linearly, e.g.

suppress weekends or compress far away points with a logarithm or some

other means. When Flot draws the plot, each value is first put through

the transform function. Here’s an example, the x axis can be turned

into a natural logarithm axis with the following code:

“transform” and “inverseTransform” 是回调函数,用于改变数轴上的数据显示方式,


xaxis: {

transform: function (v) { return Math.log(v); },

inverseTransform: function (v) { return Math.exp(v); }


Note that for finding extrema, Flot assumes that the transform

function does not reorder values (monotonicity is assumed).


The inverseTransform is simply the inverse of the transform function

(so v == inverseTransform(transform(v)) for all relevant v). It is

required for converting from canvas coordinates to data coordinates,

e.g. for a mouse interaction where a certain pixel is clicked. If you

don’t use any interactive features of Flot, you may not need it.

inverseTransform 函数是对transform的逆运算,因此有:v == inverseTransform(transform(v)



The rest of the options deal with the ticks.


If you don’t specify any ticks, a tick generator algorithm will make

some for you. The algorithm has two passes. It first estimates how

many ticks would be reasonable and uses this number to compute a nice

round tick interval size. Then it generates the ticks.



You can specify how many ticks the algorithm aims for by setting

“ticks” to a number. The algorithm always tries to generate reasonably

round tick values so even if you ask for three ticks, you might get

five if that fits better with the rounding. If you don’t want any

ticks at all, set “ticks” to 0 or an empty array.

通过设置”ticks” 的值为数字,你可以设置图表产生刻度间隔的个数,但是程序尽量会设置最合适的刻度


Another option is to skip the rounding part and directly set the tick

interval size with “tickSize”. If you set it to 2, you’ll get ticks at

2, 4, 6, etc. Alternatively, you can specify that you just don’t want

ticks at a size less than a specific tick size with “minTickSize”.

Note that for time series, the format is an array like [2, “month”],

see the next section.



If you want to completely override the tick algorithm, you can specify

an array for “ticks”, either like this:


ticks: [0, 1.2, 2.4]

Or like this where the labels are also customized:


ticks: [[0, “zero”], [1.2, “one mark”], [2.4, “two marks”]]

You can mix the two if you like.


For extra flexibility you can specify a function as the “ticks”

parameter. The function will be called with an object with the axis

min and max and should return a ticks array. Here’s a simplistic tick

generator that spits out intervals of pi, suitable for use on the x

axis for trigonometric functions:




function piTickGenerator(axis) {

var res = [], i = Math.floor(axis.min / Math.PI);

do {

var v = i * Math.PI;

res.push([v, i + “\u03c0”]);


} while (v < axis.max);

return res;


You can control how the ticks look like with “tickDecimals”, the

number of decimals to display (default is auto-detected).

“tickDecimals” 用于设置刻度的小数位数,默认情况下程序会自动判断截取

Alternatively, for ultimate control over how ticks look like you can

provide a function to “tickFormatter”. The function is passed two

parameters, the tick value and an “axis” object with information, and

should return a string. The default formatter looks like this:



function formatter(val, axis) {

return val.toFixed(axis.tickDecimals);


The axis object has “min” and “max” with the range of the axis,

“tickDecimals” with the number of decimals to round the value to and

“tickSize” with the size of the interval between ticks as calculated

by the automatic axis scaling algorithm (or specified by you). Here’s

an example of a custom formatter:



function suffixFormatter(val, axis) {

if (val > 1000000)

return (val / 1000000).toFixed(axis.tickDecimals) + ” MB”; // toFixed() 函数,把数值四舍五入为指定小数位数

else if (val > 1000)

return (val / 1000).toFixed(axis.tickDecimals) + ” kB”;


return val.toFixed(axis.tickDecimals) + ” B”;


Time series data



Time series are a bit more difficult than scalar data because

calendars don’t follow a simple base 10 system. For many cases, Flot

abstracts most of this away, but it can still be a bit difficult to

get the data into Flot. So we’ll first discuss the data format.


The time series support in Flot is based on Javascript timestamps,

i.e. everywhere a time value is expected or handed over, a Javascript

timestamp number is used. This is a number, not a Date object. A

Javascript timestamp is the number of milliseconds since January 1,

1970 00:00:00 UTC. This is almost the same as Unix timestamps, except it’s

in milliseconds, so remember to multiply by 1000!





You can see a timestamp like this


alert((new Date()).getTime())

Normally you want the timestamps to be displayed according to a

certain time zone, usually the time zone in which the data has been

produced. However, Flot always displays timestamps according to UTC.

It has to as the only alternative with core Javascript is to interpret

the timestamps according to the time zone that the visitor is in,

which means that the ticks will shift unpredictably with the time zone

and daylight savings of each visitor.



So given that there’s no good support for custom time zones in

Javascript, you’ll have to take care of this server-side.


The easiest way to think about it is to pretend that the data

production time zone is UTC, even if it isn’t. So if you have a

datapoint at 2002-02-20 08:00, you can generate a timestamp for eight

o’clock UTC even if it really happened eight o’clock UTC+0200.


在2002-02-20 08:00产生,就算是在UTC+0200 时区8时产生的,你也要按UTC时区8时产生时间戳。


In PHP you can get an appropriate timestamp with

‘strtotime(“2002-02-20 UTC”) * 1000’, in Python with

‘calendar.timegm(datetime_object.timetuple()) * 1000’, in .NET with

something like:


在PHP程序中 strtotime(“2002-02-20 UTC”) * 1000

Python中 calendar.timegm(datetime_object.timetuple()) * 1000

在 .net中代码如下:

public static int GetJavascriptTimestamp(System.DateTime input)


System.TimeSpan span = new System.TimeSpan(System.DateTime.Parse(“1/1/1970”).Ticks);

System.DateTime time = input.Subtract(span);

return (long)(time.Ticks / 10000);


Javascript also has some support for parsing date strings, so it is

possible to generate the timestamps manually client-side.

javascript 也有一些对时间字符串进行解析的支持,因此在客户端生成时间戳也是可能的。

If you’ve already got the real UTC timestamp, it’s too late to use the

pretend trick described above. But you can fix up the timestamps by

adding the time zone offset, e.g. for UTC+0200 you would add 2 hours

to the UTC timestamp you got. Then it’ll look right on the plot. Most

programming environments have some means of getting the timezone

offset for a specific date (note that you need to get the offset for

each individual timestamp to account for daylight savings).






Once you’ve gotten the timestamps into the data and specified “time”

as the axis mode, Flot will automatically generate relevant ticks and

format them. As always, you can tweak the ticks via the “ticks” option

– just remember that the values should be timestamps (numbers), not

Date objects.



Tick generation and formatting can also be controlled separately

through the following axis options:


minTickSize: array

timeformat: null or format string //null 或格式化字符串

monthNames: null or array of size 12 of strings //null或一个长度为12的字符串数组

twelveHourClock: boolean //12时模式

Here “timeformat” is a format string to use. You might use it like this:


xaxis: {

mode: “time”

timeformat: “%y/%m/%d”


This will result in tick labels like “2000/12/24”. The following

specifiers are supported

这个例子产生的时间抽刻度标签形如”2000/12/24″ ,下面是flot支持的时间格式化字符串:

%h: hours

%H: hours (left-padded with a zero)

%M: minutes (left-padded with a zero)

%S: seconds (left-padded with a zero)

%d: day of month (1-31)

%m: month (1-12)

%y: year (four digits)

%b: month name (customizable)

%p: am/pm, additionally switches %h/%H to 12 hour instead of 24

%P: AM/PM (uppercase version of %p)

You can customize the month names with the “monthNames” option. For

instance, for Danish you might specify:

“monthNames” 参数自定义月份名称的方法如下:

monthNames: [“jan”, “feb”, “mar”, “apr”, “maj”, “jun”, “jul”, “aug”, “sep”, “okt”, “nov”, “dec”]

If you set “twelveHourClock” to true, the autogenerated timestamps

will use 12 hour AM/PM timestamps instead of 24 hour.

“twelveHourClock”设置为true,将使用12时AM/PM 格式的时间戳来替代24时时间戳。

The format string and month names are used by a very simple built-in

format function that takes a date object, a format string (and

optionally an array of month names) and returns the formatted string.

If needed, you can access it as $.plot.formatDate(date, formatstring,

monthNames) or even replace it with another more advanced function

from a date library if you’re feeling adventurous.


返回格式化了的字符串,如果需要,你可以使用flot提供的方法 $.plot.formatDate(date, formatstring,monthNames)


If everything else fails, you can control the formatting by specifying

a custom tick formatter function as usual. Here’s a simple example

which will format December 24 as 24/12:


tickFormatter: function (val, axis) {

var d = new Date(val);

return d.getUTCDate() + “/” + (d.getUTCMonth() + 1);


Note that for the time mode “tickSize” and “minTickSize” are a bit

special in that they are arrays on the form “[value, unit]” where unit

is one of “second”, “minute”, “hour”, “day”, “month” and “year”. So

you can specify

请注意,时间轴的”tickSize” 和 “minTickSize”是一个数组,数组形如 [数值,单位],

单位可以是 “second”, “minute”, “hour”, “day”, “month” and “year” ,因此你可以这样设置最小刻度为一个月:

minTickSize: [1, “month”]

to get a tick interval size of at least 1 month and correspondingly,

if axis.tickSize is [2, “day”] in the tick formatter, the ticks have

been produced with two days in-between.

类似地,axis.tickSize设置为[2, “day”],则时间轴最小刻度为2天。

Customizing the data series



series: {

lines, points, bars: {

show: boolean

lineWidth: number

fill: boolean or number

fillColor: null or color/gradient


points: {

radius: number


bars: {

barWidth: number

align: “left” or “center”

horizontal: boolean


lines: {

steps: boolean


shadowSize: number


colors: [ color1, color2, … ]

The options inside “series: {}” are copied to each of the series. So

you can specify that all series should have bars by putting it in the

global options, or override it for individual series by specifying

bars in a particular the series object in the array of data.

“series: {}” 内的参数将对每一个数据序列生效,可以用来为图表设置全局参数,


The most important options are “lines”, “points” and “bars” that

specify whether and how lines, points and bars should be shown for

each data series. In case you don’t specify anything at all, Flot will

default to showing lines (you can turn this off with

lines: { show: false}). You can specify the various types

independently of each other, and Flot will happily draw each of them

in turn (this is probably only useful for lines and points), e.g.

“lines”, “points” 和 “bars”是最重要的参数,这些参数设置每条数据序列的图表的折线图、散点图、直方图是否显示和如何显示。

如果没有专门设置这三个参数中的任何一个,默认情况下将显示折线图,关闭折线图的方法是lines: { show: false}


var options = {

series: {

lines: { show: true, fill: true, fillColor: “rgba(255, 255, 255, 0.8)” },

points: { show: true, fill: false }



“lineWidth” is the thickness of the line or outline in pixels. You can

set it to 0 to prevent a line or outline from being drawn; this will

also hide the shadow.



“fill” is whether the shape should be filled. For lines, this produces

area graphs. You can use “fillColor” to specify the color of the fill.

If “fillColor” evaluates to false (default for everything except

points which are filled with white), the fill color is auto-set to the

color of the data series. You can adjust the opacity of the fill by

setting fill to a number between 0 (fully transparent) and 1 (fully


“fill” 用于设置图表填充的透明度(0-1),对于折线,填充范围是折线与数轴围成的区域

“fillColor” 设置填充颜色,如果填null,将使用线条颜色一致的颜色,如果颜色名解析失败将使用默认颜色(折线图直方图黑色,散点图白色)

For bars, fillColor can be a gradient, see the gradient documentation

below. “barWidth” is the width of the bars in units of the x axis (or

the y axis if “horizontal” is true), contrary to most other measures

that are specified in pixels. For instance, for time series the unit

is milliseconds so 24 * 60 * 60 * 1000 produces bars with the width of

a day. “align” specifies whether a bar should be left-aligned

(default) or centered on top of the value it represents. When

“horizontal” is on, the bars are drawn horizontally, i.e. from the y

axis instead of the x axis; note that the bar end points are still

defined in the same way so you’ll probably want to swap the

coordinates if you’ve been plotting vertical bars first.


“barWidth” 用于设置直方图的宽度,单位是数轴的单位而非像素。

例如,时间轴的单位是毫秒,因此,barWidth的值设置为24 * 60 * 60 * 1000 表示直方图的宽度是一天时间的在时间轴上的长度。

“align” 用于设置数据点对应刻度线与直方图之间的对齐关系,默认情况下,刻度线在直方图的左侧(left,靠近数轴最小值一侧),


For lines, “steps” specifies whether two adjacent data points are

connected with a straight (possibly diagonal) line or with first a

horizontal and then a vertical line. Note that this transforms the

data by adding extra points.



“shadowSize” is the default size of shadows in pixels. Set it to 0 to

remove shadows.

“shadowSize” 可以设置曲线阴影大小,设置为0关闭阴影效果。

The “colors” array specifies a default color theme to get colors for

the data series from. You can specify as many colors as you like, like



colors: [“#d18b2c”, “#dba255”, “#919733”]

If there are more data series than colors, Flot will try to generate

extra colors by lightening and darkening colors in the theme.


Customizing the grid



grid: {

show: boolean

aboveData: boolean

color: color

backgroundColor: color/gradient or null

tickColor: color

labelMargin: number

markings: array of markings or (fn: axes -> array of markings)

borderWidth: number

borderColor: color or null

clickable: boolean

hoverable: boolean

autoHighlight: boolean

mouseActiveRadius: number


The grid is the thing with the axes and a number of ticks. “color” is

the color of the grid itself whereas “backgroundColor” specifies the

background color inside the grid area. The default value of null means

that the background is transparent. You can also set a gradient, see

the gradient documentation below.





You can turn off the whole grid including tick labels by setting

“show” to false. “aboveData” determines whether the grid is drawn on

above the data or below (below is default).


“aboveData” 用于设置栅格放置在数据点上面还是下面,默认情况false是放在数据点下面。


“tickColor” is the color of the ticks and “labelMargin” is the spacing

between tick labels and the grid. Note that you can style the tick

labels with CSS, e.g. to change the color. They have class “tickLabel”.

“borderWidth” is the width of the border around the plot. Set it to 0

to disable the border. You can also set “borderColor” if you want the

border to have a different color than the grid lines.

“tickColor” 设置刻度线的颜色

“labelMargin” 设置刻度值标签与网格的距离,

“borderWidth” 设置边框宽度,设为0则取消边框

“borderColor” 设置边框颜色,

“tickLabel” 设置刻度值标签的CSS样式,(未实验,设置方法不明)

“markings” is used to draw simple lines and rectangular areas in the

background of the plot. You can either specify an array of ranges on

the form { xaxis: { from, to }, yaxis: { from, to } } (secondary axis

coordinates with x2axis/y2axis) or with a function that returns such

an array given the axes for the plot in an object as the first


You can set the color of markings by specifying “color” in the ranges

object. Here’s an example array:

“markings” 用于在背景上绘画出一块矩形,矩形的位置及长宽通过纵横轴的起始终止坐标来确定,




markings: [ { xaxis: { from: 0, to: 2 }, yaxis: { from: 10, to: 10 }, color: “#bb0000” }, … ]

If you leave out one of the values, that value is assumed to go to the

border of the plot. So for example if you only specify { xaxis: {

from: 0, to: 2 } } it means an area that extends from the top to the

bottom of the plot in the x range 0-2.

A line is drawn if from and to are the same, e.g.

markings: [ { yaxis: { from: 1, to: 1 } }, … ]

would draw a line parallel to the x axis at y = 1. You can control the

line width with “lineWidth” in the range object.



An example function might look like this:

markings: function (axes) {

var markings = [];

for (var x = Math.floor(axes.xaxis.min); x < axes.xaxis.max; x += 2)

markings.push({ xaxis: { from: x, to: x + 1 } });

return markings;


If you set “clickable” to true, the plot will listen for click events

on the plot area and fire a “plotclick” event on the placeholder with

a position and a nearby data item object as parameters. The coordinates

are available both in the unit of the axes (not in pixels) and in

global screen coordinates.

“clickable” 设置为true时,图表将监听鼠标单击事件,单击图表时将触发”plotclick”事件,



Likewise, if you set “hoverable” to true, the plot will listen for

mouse move events on the plot area and fire a “plothover” event with

the same parameters as the “plotclick” event. If “autoHighlight” is

true (the default), nearby data items are highlighted automatically.

If needed, you can disable highlighting and control it yourself with

the highlight/unhighlight plot methods described elsewhere.

同样地,”hoverable” 设置为true将监听鼠标移动事件,鼠标移动到某个位置时发生”plothover”事件,




You can use “plotclick” and “plothover” events like this:

“plotclick” 和 “plothover” 事件用法如下:

$.plot($(“#placeholder”), [ d ], { grid: { clickable: true } });

$(“#placeholder”).bind(“plotclick”, function (event, pos, item) {

alert(“You clicked at ” + pos.x + “, ” + pos.y);

// secondary axis coordinates if present are in pos.x2, pos.y2, //pos.x pos.y 数轴坐标值,pos.x2, pos.y2 第二对数轴的坐标值

// if you need global screen coordinates, they are pos.pageX, pos.pageY //pos.pageX, pos.pageY 屏幕坐标值

if (item) { //item !=null ,点击了数据点

highlight(item.series, item.datapoint); // item.datapoint 该数据点的纵横坐标值,是一对以逗号分割的数值 如: 3.5,2.14 表示该点X轴的值为3.5,Y轴的值为2.14

alert(“You clicked a point!”); //注意,item.datapoint的值不一定与 pos.x pos.y的值相等,因为点击在数据点附近,数据点也激活了



The item object in this example is either null or a nearby object on the form:

item: { //item参数的属性

datapoint: the point, e.g. [0, 2]

dataIndex: the index of the point in the data array //该点数据在对应数列数组里的下标

series: the series object //曲线对象

seriesIndex: the index of the series //在多曲线体系中该曲线的下标,即第几条曲线,编号从0开始

pageX, pageY: the global screen coordinates of the point //该点屏幕坐标,单位是像素


For instance, if you have specified the data like this


$.plot($(“#placeholder”), [ { label: “Foo”, data: [[0, 10], [7, 3]] } ], …);

and the mouse is near the point (7, 3), “datapoint” is [7, 3],

“dataIndex” will be 1, “series” is a normalized series object with

among other things the “Foo” label in series.label and the color in

series.color, and “seriesIndex” is 0. Note that plugins and options

that transform the data can shift the indexes from what you specified

in the original data array.

鼠标的(7,3)坐标附近触发事件时,”datapoint” 的值是[7,3],


item.dataIndex ==1

item.seriesIndex == 0

item.series 曲线对象,

item.series.label ==”Foo” 曲线名称

item.series.color 曲线颜色,rgb格式

If you use the above events to update some other information and want

to clear out that info in case the mouse goes away, you’ll probably

also need to listen to “mouseout” events on the placeholder div.


“mouseActiveRadius” specifies how far the mouse can be from an item

and still activate it. If there are two or more points within this

radius, Flot chooses the closest item. For bars, the top-most bar

(from the latest specified data series) is chosen.

“mouseActiveRadius” 用来设置可以激活数据点的鼠标与数据点之间的距离,如果在符合距离内有多个数据点,flot会激活最近的数据点


If you want to disable interactivity for a specific data series, you

can set “hoverable” and “clickable” to false in the options for that

series, like this { data: […], label: “Foo”, clickable: false }.

在某条曲线数据本身设置”hoverable” 和 “clickable” 为false则该曲线不会触发事件


Specifying gradients



A gradient is specified like this:


{ colors: [ color1, color2, … ] }

For instance, you might specify a background on the grid going from

black to gray like this:


grid: {

backgroundColor: { colors: [“#000”, “#999”] }


For the series you can specify the gradient as an object that

specifies the scaling of the brightness and the opacity of the series

color, e.g.


{ colors: [{ opacity: 0.8 }, { brightness: 0.6, opacity: 0.8 } ] }

where the first color simply has its alpha scaled, whereas the second

is also darkened. For instance, for bars the following makes the bars

gradually disappear, without outline:


bars: {

show: true,

lineWidth: 0,

fill: true,

fillColor: { colors: [ { opacity: 0.8 }, { opacity: 0.1 } ] }


Flot currently only supports vertical gradients drawn from top to

bottom because that’s what works with IE.


Plot Methods



The Plot object returned from the plot function has some methods you

can call:


– highlight(series, datapoint) //激活数据点 series:曲线编号,datapoint:数据点在曲线数据序列中的编号,编号都是从0开始 例如:highlight(1, 1) 激活第二条曲线的第二个数据点

//datapoint 也可以是一个数据点的真实数据对象,是一个数组, 例如: highlight(1, [3,6]) 激活第二条曲线上坐标为[3,6]的点


Highlight a specific datapoint in the data series. You can either

specify the actual objects, e.g. if you got them from a

“plotclick” event, or you can specify the indices, e.g.

highlight(1, 3) to highlight the fourth point in the second series

(remember, zero-based indexing).

– unhighlight(series, datapoint) or unhighlight() //取消数据点的激活效果,参数与highlight相同

Remove the highlighting of the point, same parameters as


If you call unhighlight with no parameters, e.g. as

plot.unhighlight(), all current highlights are removed. //如果unhighlight()没有设置参数,取消所有数据点的激活状态

– setData(data)

You can use this to reset the data used. Note that axis scaling,

ticks, legend etc. will not be recomputed (use setupGrid() to do

that). You’ll probably want to call draw() afterwards.

重新设置曲线数据,参数data是plot(placeholder, data, options)中的data参数,可以不包含options的设置内容。



You can use this function to speed up redrawing a small plot if

you know that the axes won’t change. Put in the new data with

setData(newdata), call draw(), and you’re good to go. Note that

for large datasets, almost all the time is consumed in draw()

plotting the data so in this case don’t bother.



– setupGrid()

Recalculate and set axis scaling, ticks, legend etc.

修改数轴、刻度、曲线名称等,参数是 options 不包括data部分

Note that because of the drawing model of the canvas, this

function will immediately redraw (actually reinsert in the DOM)

the labels and the legend, but not the actual tick lines because

they’re drawn on the canvas. You need to call draw() to get the

canvas redrawn.



应该注意,如果原来图表上没有的数轴,在setupGrid()设置之后出现该数轴,那么 该数轴会叠在Grid上,

– draw()

Redraws the plot canvas. //重绘图表的canvas

– triggerRedrawOverlay()

Schedules an update of an overlay canvas used for drawing

interactive things like a selection and point highlights. This

is mostly useful for writing plugins. The redraw doesn’t happen

immediately, instead a timer is set to catch multiple successive

redraws (e.g. from a mousemove).




– width()/height()

Gets the width and height of the plotting area inside the grid.

This is smaller than the canvas or placeholder dimensions as some

extra space is needed (e.g. for labels).


– offset()

Returns the offset of the plotting area inside the grid relative

to the document, useful for instance for calculating mouse

positions (event.pageX/Y minus this offset is the pixel position

inside the plot).


offset().left , offset().top 获取左偏移和顶部偏移

– pointOffset({ x: xpos, y: ypos })

Returns the calculated offset of the data point at (x, y) in data

space within the placeholder div. If you are working with dual axes, you

can specify the x and y axis references, e.g.



pointOffset({ x: 3, y: 3.5 }).left pointOffset({ x: 3, y: 3.5 }).top 分别是数据点(3,3.5)位置相对于容器DIV的偏移

o = pointOffset({ x: xpos, y: ypos, xaxis: 2, yaxis: 2 })

// o.left and o.top now contains the offset within the div

There are also some members that let you peek inside the internal

workings of Flot which is useful in some cases. Note that if you change

something in the objects returned, you’re changing the objects used by

Flot to keep track of its state, so be careful.


– getData()

Returns an array of the data series currently used in normalized

form with missing settings filled in according to the global

options. So for instance to find out what color Flot has assigned

to the data series, you could do this:

获取plot(placeholder, data, options) 函数的data 和 options 合成的数据,

getData() 并非仅仅返回函数的 data 参数,他是一个数组,里面的信息包含了这个曲线的信息,


注意与setData()的参数区别,oo.setData(data), 则 data!= oo.getData()

var series = plot.getData();

for (var i = 0; i < series.length; ++i)

alert(series[i].color); //逐个弹出曲线的颜色

A notable other interesting field besides color is datapoints

which has a field “points” with the normalized data points in a

flat array (the field “pointsize” is the increment in the flat

array to get to the next point so for a dataset consisting only of

(x,y) pairs it would be 2).

– getAxes()

Gets an object with the axes settings as { xaxis, yaxis, x2axis,

y2axis }.

该方法返回数轴信息的json对象,该对象有四个成员,分别为xaxis, yaxis, x2axis, y2axis 四条数轴

Various things are stuffed inside an axis object, e.g. you could

use getAxes().xaxis.ticks to find out what the ticks are for the

xaxis. Two other useful attributes are p2c and c2p, functions for

transforming from data point space to the canvas plot space and

back. Both returns values that are offset with the plot offset.


例如获取X轴第一个刻度标签: getAxes().xaxis.ticks[0].label

【c2p p2c两个函数是用于计算并返回数据点与数轴直接的偏移量(包含曲线偏移量)】 看不太明白,待证实

– getPlaceholder()

Returns placeholder that the plot was put into. This can be useful

for plugins for adding DOM elements or firing events.


getPlaceholder().selector 返回该容器的jQuery选择器,即 ‘#’ + id

– getCanvas()

Returns the canvas used for drawing in case you need to hack on it

yourself. You’ll probably need to get the plot offset too.


– getPlotOffset()

Gets the offset that the grid has within the canvas as an object

with distances from the canvas edges as “left”, “right”, “top”,

“bottom”. I.e., if you draw a circle on the canvas with the center

placed at (left, top), its center will be at the top-most, left

corner of the grid.


该方法返回一个json对象,形如 {left:36,right:6,top:6,bottom:20}

– getOptions()

Gets the options for the plot, in a normalized format with default

values filled in.





In addition to the public methods, the Plot object also has some hooks

that can be used to modify the plotting process. You can install a

callback function at various points in the process, the function then

gets access to the internal data structures in Flot.



Here’s an overview of the phases Flot goes through:


1. Plugin initialization, parsing options //初始化引入的插件(如果有的话)设置,解析options的参数设置

2. Constructing the canvases used for drawing //创建canvas标签

3. Set data: parsing data specification, calculating colors,

copying raw data points into internal format,

normalizing them, finding max/min for axis auto-scaling


4. Grid setup: calculating axis spacing, ticks, inserting tick

labels, the legend


5. Draw: drawing the grid, drawing each of the series in turn


6. Setting up event handling for interactive features


7. Responding to events, if any


Each hook is simply a function which is put in the appropriate array.

You can add them through the “hooks” option, and they are also available

after the plot is constructed as the “hooks” attribute on the returned

plot object, e.g.



// define a simple draw hook

function hellohook(plot, canvascontext) { alert(“hello!”); };

// pass it in, in an array since we might want to specify several

var plot = $.plot(placeholder, data, { hooks: { draw: [hellohook] } });

// we can now find it again in plot.hooks.draw[0] unless a plugin

// has added other hooks

The available hooks are described below. All hook callbacks get the

plot object as first parameter. You can find some examples of defined

hooks in the plugins bundled with Flot.


– processOptions [phase 1]

function(plot, options)

Called after Flot has parsed and merged options. Useful in the

instance where customizations beyond simple merging of default

values is needed. A plugin might use it to detect that it has been

enabled and then turn on or off other options.


– processRawData [phase 3]

function(plot, series, data, datapoints)

Called before Flot copies and normalizes the raw data for the given

series. If the function fills in datapoints.points with normalized

points and sets datapoints.pointsize to the size of the points,

Flot will skip the copying/normalization step for this series.


In any case, you might be interested in setting datapoints.format,

an array of objects for specifying how a point is normalized and

how it interferes with axis scaling.

The default format array for points is something along the lines of:


{ x: true, number: true, required: true },

{ y: true, number: true, required: true }


The first object means that for the first coordinate it should be

taken into account when scaling the x axis, that it must be a

number, and that it is required – so if it is null or cannot be

converted to a number, the whole point will be zeroed out with

nulls. Beyond these you can also specify “defaultValue”, a value to

use if the coordinate is null. This is for instance handy for bars

where one can omit the third coordinate (the bottom of the bar)

which then defaults to 0.

– processDatapoints [phase 3]

function(plot, series, datapoints)

Called after normalization of the given series but before finding

min/max of the data points. This hook is useful for implementing data

transformations. “datapoints” contains the normalized data points in

a flat array as datapoints.points with the size of a single point

given in datapoints.pointsize. Here’s a simple transform that

multiplies all y coordinates by 2:

function multiply(plot, series, datapoints) {

var points = datapoints.points, ps = datapoints.pointsize;

for (var i = 0; i < points.length; i += ps)

points[i + 1] *= 2;


Note that you must leave datapoints in a good condition as Flot

doesn’t check it or do any normalization on it afterwards.

– draw [phase 5]

function(plot, canvascontext)

Hook for drawing on the canvas. Called after the grid is drawn

(unless it’s disabled) and the series have been plotted (in case

any points, lines or bars have been turned on). For examples of how

to draw things, look at the source code.

– bindEvents [phase 6]

function(plot, eventHolder)

Called after Flot has setup its event handlers. Should set any

necessary event handlers on eventHolder, a jQuery object with the

canvas, e.g.

function (plot, eventHolder) {

eventHolder.mousedown(function (e) {

alert(“You pressed the mouse at ” + e.pageX + ” ” + e.pageY);



Interesting events include click, mousemove, mouseup/down. You can

use all jQuery events. Usually, the event handlers will update the

state by drawing something (add a drawOverlay hook and call

triggerRedrawOverlay) or firing an externally visible event for

user code. See the crosshair plugin for an example.

Currently, eventHolder actually contains both the static canvas

used for the plot itself and the overlay canvas used for

interactive features because some versions of IE get the stacking

order wrong. The hook only gets one event, though (either for the

overlay or for the static canvas).

– drawOverlay [phase 7]

function (plot, canvascontext)

The drawOverlay hook is used for interactive things that need a

canvas to draw on. The model currently used by Flot works the way

that an extra overlay canvas is positioned on top of the static

canvas. This overlay is cleared and then completely redrawn

whenever something interesting happens. This hook is called when

the overlay canvas is to be redrawn.

“canvascontext” is the 2D context of the overlay canvas. You can

use this to draw things. You’ll most likely need some of the

metrics computed by Flot, e.g. plot.width()/plot.height(). See the

crosshair plugin for an example.




Plugins extend the functionality of Flot. To use a plugin, simply

include its Javascript file after Flot in the HTML page.

If you’re worried about download size/latency, you can concatenate all

the plugins you use, and Flot itself for that matter, into one big file

(make sure you get the order right), then optionally run it through a

Javascript minifier such as YUI Compressor.

Here’s a brief explanation of how the plugin plumbings work:

Each plugin registers itself in the global array $.plot.plugins. When

you make a new plot object with $.plot, Flot goes through this array

calling the “init” function of each plugin and merging default options

from its “option” attribute. The init function gets a reference to the

plot object created and uses this to register hooks and add new public

methods if needed.

See the PLUGINS.txt file for details on how to write a plugin. As the

above description hints, it’s actually pretty easy.




$(“#placeholder”).bind(“plotselected”, function (event, ranges){ //doSomething })

其中ranges参数记录了选择曲线的区域,是一个json 对象,内容是各个数轴的选中区域起止点的值,形如:






plot.setSelection(ranges,true) 方法,按ranges指定范围设置选中区域,



<script type=”text/javascript”>

var JsonStr = function(JsonStrObj){

this.objType = (typeof JsonStrObj);

this.self = [];

(function(s,o){for(var i in o){o.hasOwnProperty(i)&&(s[i]=o[i],s.self[i]=o[i])};})(this,(this.objType==’string’)?eval(‘0,’+JsonStrObj):JsonStrObj);


JsonStr.prototype = {


return this.getString();



return this.getString();



var sA = [];


var oo = null;


for(var i in o){

if(o.hasOwnProperty(i) && i!=’prototype’){

oo = o[i];

if(oo instanceof Array){


for(var b in oo){

if(oo.hasOwnProperty(b) && b!=’prototype’){


if(typeof oo==’object’) arguments.callee(oo);








if(typeof oo==’object’) arguments.callee(oo);





return sA.slice(0).join(”).replace(/\[object object\],/ig,”).replace(/,\}/g,’}’).replace(/,\]/g,’]’).slice(0,-1);



this.self[sName] = sValue;

this[sName] = sValue;




var jsonStr = new JsonStr(JsonObj); //JsonObj 是一个json对象



如果你对这篇文章有疑问,欢迎到本站 社区 发帖提问或使用手Q扫描下方二维码加群参与讨论,获取更多帮助。



需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。





2891 文章
84935 人气



文章 0 评论


文章 0 评论


文章 0 评论


文章 0 评论


文章 0 评论