Util

获取方式:G6.Util

G6.Util 是一个工具类,里面提供了大量工具方法给开发者使用。

方法

isNode {Function}

判断子项是否是节点

/**
 * 判断是否是节点
 * @param {Object} item 子项
 * @return {Boolean}
 */
G6.Util.isNode(item);

isEdge {Function}

判断子项是否是边

/**
 * 判断是否是边
 * @param {Object} item 子项
 * @return {Boolean}
 */
G6.Util.isEdge(item);

substitute {Function}

替换字符串中的字段,返回匹配字符串的正则表达式。

/**
 * 替换字符串中的字段.
 * @param  {String} str 模版字符串
 * @param  {Object} o   json data
 * @return {String} rst 匹配后的字符串
 */
G6.Util.substitute(str, o);

ucfirst {Function}

将字符串的第一个字母变成大写。

/**
 * 使第一个字母变成大写
 * @param  {String} s 字符串
 * @return {String} 首字母大写后的字符串
 */
G6.Util.ucfirst(s);

isObject {Function}

判断参数是否为对象。

/**
 * 是否是javascript对象
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isObject(value);

isNumber {Function}

判断参数是否为数字。

/**
 * 判断是否数字
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isNumber(value);

isNumeric {Function}

是否是数字或者数字字符串(类似 '124')。

/**
 * 判断是否数字或者数字字符串,由于$.isNumberic方法会把 '123'认为数字
 * @param  {*} value 测试的值
 * @return {Boolean} 是否数字
 */
G6.Util.isNumeric(value);

isBoolean {Function}

判断参数是否为布尔值。

/**
 * 是否是布尔类型
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isBoolean(value);

isFunction {Function}

判断参数是否为函数。

/**
 * 是否为函数
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isFunction(value);

isArray {Function}

判断参数是否为数组。

/**
 * 是否数组
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isArray(value);

isDate {Function}

判断参数是否为日期。

/**
 * 是否日期
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isDate(value);

isNull {Function}

判断一个对象是否是 null 或者 undefined。

/**
 * 对象是否为空
 * @param  {*} value 测试的值
 * @return {Boolean}
 */
G6.Util.isNull(value);

mix {Function}

合并各个对象。

/**
 * 合并数据
 * @return {Object} 将数据合并到第一个
 */
G6.Util.mix(target, source1, source2....source);

若第一个参数为true,则为深层合并。

/**
 * 合并数据
 * @return {Object} 将数据合并到第一个
 */
G6.Util.mix(true, target, source1, source2....source);

map {Function}

转换数值的值。

/**
 * map 数组
 * @param  {Array} arr 数组
 */
G6.Util.map(arr);

filter {Function}

过滤数组。

/**
 * 过滤数组
 * @param {Object|Array} element/Object 数组中的元素或者对象的值
 * @param {Function} func 遍历的函数 function(elememt,index){} 或者 function(value,key){},如果返回true则添加到结果集
 * @return {Array} 过滤的结果集
 */
G6.Util.filter(arr, func);

each {Function}

遍历数组或者对象。

/**
 * 遍历数组或者对象
 * @param {Object|Array} element/Object 数组中的元素或者对象的值
 * @param {Function} func 遍历的函数 function(elememt,index){} 或者 function(value,key){}
 */
G6.Util.each(elements, func);

indexOf {Function}

返回 value 在数组中的索引。

/**
 * 查找元素在数组中的位置,如果不存在则返回-1
 * @param  {Array} arr 数组
 * @param  {*} obj 查找的元素
 * @return {Number} 位置
 */
G6.Util.indexOf(arr, obj);

empty {Function}

清空。

/**
 * 清空
 * @param  {Array} array 数组
 */
G6.Util.empty(array);

guid {Function}

产生唯一码。

/**
 * 生成唯一的Id
 * @return {String} 唯一的编号
 */
G6.Util.guid();

getEllipsePath {Function}

获取椭圆路径

/**
 * 获取椭圆路径
 * @param {Number} x    中心x坐标
 * @param {Number} y    中心y坐标
 * @param {Number} rx   横轴半径
 * @param {Number} ry   纵轴
 * @return {Array} Path 路径
 */
G6.Util.getEllipsePath(x, y, rx, ry);

pointsToPolygon {Function}

点集转化为Path多边形

/**
 * 点集转化为Path多边形
 * @param {Array}  points 点集
 * @param {Boolen} z      是否封闭
 * @return {Array} Path   路径
 */
G6.Util.pointsToPolygon(points, z);

pointsToCurve {Function}

点集到曲线

/**
 * 点集到贝塞尔曲线
 * @param  {Array} points 点集
 * @return {Array} Path   路径
 */
G6.Util.pointsToCurve(points);

arrowTo {Function}

将图形指向指定方向

/**
 * 放置箭头
 * @param {Ganvas.Element}  element 形
 * @param {Number}          x       位置x
 * @param {Number}          y       位置y
 * @param {Number}          x0      方向起点x
 * @param {Number}          y0      方向起点y
 * @param {Number}          x1      方向终点x
 * @param {Number}          y1      方向终点y
 * @return {Ganvas.Element} element 形
 */
G6.Util.arrowTo(element, x, y, x0, y0, x1, y1);

pathIntersection {Function}

算两条path的交点

/**
 * path相交
 * @param  {String|Array} path1 路径1
 * @param  {String|Array} path2 路径2
 * @return {Array} rst
 */
G6.Util.pathIntersection(path1, path2);

getSnapAnchor {Function}

获取节点逼近的锚点

/**
 * 获取逼近的锚点
 * @param {Node}    node  节点
 * @param {Object}  point 用于逼近点
 * @return {Object} rst   逼近点
 */
G6.Util.getSnapAnchor(node, point);