Vue 处理异步加载顺序问题:在Konva中确保文本在Konva之上显示

目录
文章目录隐藏
  1. 问题描述
  2. 初步实现
  3. 异步问题
  4. 尝试 1:直接回调
  5. 尝试 2:在函数中写回调
  6. 尝试 3:将回调移至 imageObj.onload 内部
  7. 比较两种实现方式
  8. 结语

在使用 Konva 开发应用时,我们经常会遇到需要将文本绘制在图片之上的情况。一个常见的问题是,由于图像加载是异步的,文本有时会显示在图片下方。本篇博客将总结如何正确处理这种异步加载顺序问题。

问题描述

我们希望在绘制图片后,再在图片上方绘制文本。一个简单的代码片段如下:

for (let i = 0; i < 4; i++) {
    const geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100),
        width: 100,
        height: 100,
    };
 
    addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

初步实现

我们实现了两个函数:addWidgetImgToLayer用于加载图片,addShapesToLayer用于添加 Shapes(这里添加了 Text)。

const addWidgetImgToLayer = (geometry, src, listening = false, parent, eventType, eventFunc, callback) => {
    const layer = konvaStore.layers['consoleLayer'];
    const imageObj = new Image();
    let konvaImage = null;
 
    imageObj.onload = () => {
        konvaImage = new Konva.Image({
            ...geometry,
            image: imageObj,
            listening: listening,
        });
        if (eventType && eventFunc) {
            konvaImage.on(eventType, eventFunc);
        }
        if (parent) {
            parent.add(konvaImage);
        } else {
            layer.add(konvaImage);
        }
        layer.batchDraw();
        if (callback) {
            callback();
        }
    };
    imageObj.src = src;
    return imageObj;
};
 
const addShapesToLayer = (geometry, type, listening = false, parent, text) => {
    const layer = konvaStore.layers['consoleLayer'];
    let shape = null;
    if (type === 'text') {
        shape = new Konva.Text({
            ...geometry,
            listening: listening,
            text: text,
            fontSize: 20,
            align: 'center',
            verticalAlign: 'middle',
        });
    }
    if (parent) {
        parent.add(shape);
    } else {
        layer.add(shape);
    }
    layer.batchDraw();
    return shape;
};

异步问题

这里的关键在于imageObj.onload回调函数。图片加载是异步的,代码不会等待图片加载完成才执行接下来的语句。因此,必须确保回调函数在图片加载完成后才执行添加文本的操作。

尝试 1:直接回调

我们首先尝试使用回调来确保顺序执行:

for (let i = 0; i < 4; i++) {
    const geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100),
        width: 100,
        height: 100,
    };
 
    addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

然而,这种方式下,我们遇到了无法传递参数的问题。在回调函数中,无法访问循环中的变量geometrygroup

尝试 2:在函数中写回调

我们尝试在addWidgetImgToLayer函数中编写回调,但放在了imageObj.onload之外:

const addWidgetImgToLayer = (geometry, src, listening = false, parent, eventType, eventFunc, callback) => {
    const layer = konvaStore.layers['consoleLayer'];
    const imageObj = new Image();
    let konvaImage = null;
 
    imageObj.onload = () => {
        konvaImage = new Konva.Image({
            ...geometry,
            image: imageObj,
            listening: listening,
        });
        if (eventType && eventFunc) {
            konvaImage.on(eventType, eventFunc);
        }
        if (parent) {
            parent.add(konvaImage);
        } else {
            layer.add(konvaImage);
        }
        layer.batchDraw();
    };
    
    if (callback) {
        callback();
    }
    
    imageObj.src = src;
    return imageObj;
};

这导致了文本依然在图片下方的问题,因为回调函数立即执行,而不是等待图片加载完成再执行。分析发现,问题依然是异步加载的问题,即使解决了参数传递问题,这种方法也不能正确得到想要的结果。

尝试 3:将回调移至 imageObj.onload 内部

我们意识到了 JavaScript 的异步执行机制。在函数嵌套的情况下,异步函数会在调用堆栈清空后才执行。我们需要确保回调函数在图片加载完成后才执行。

const addWidgetImgToLayer = (geometry, src, listening = false, parent, eventType, eventFunc, callback) => {
    const layer = konvaStore.layers['consoleLayer'];
    const imageObj = new Image();
    let konvaImage = null;
 
    imageObj.onload = () => {
        konvaImage = new Konva.Image({
            ...geometry,
            image: imageObj,
            listening: listening,
        });
        if (eventType && eventFunc) {
            konvaImage.on(eventType, eventFunc);
        }
        if (parent) {
            parent.add(konvaImage);
        } else {
            layer.add(konvaImage);
        }
        layer.batchDraw();
        
        if (callback) {
            callback();
        }
    };
    imageObj.src = src;
    return imageObj;
};
 
// 使用 addWidgetImgToLayer 并确保回调在图片加载完成后执行
for (let i = 0; i < 4; i++) {
    const geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100), width: 100, height: 100, }; // 这里可以使用两种不同的实现方式,现在是比较简洁的格式,下面会详细说明 addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

比较两种实现方式

在解决这个问题时,我们还可以采用两种不同的实现方式:

方式 1:使用立即执行函数表达式(IIFE)

addWidgetImgToLayer(dispBtnGeometrys[i], './img/b.png', true, group, 'click', () => { }, (function (geo, grp, idx) {
    return function () {
        addShapesToLayer(geo, 'text', false, grp, `${idx}`);
    };
})(dispBtnGeometrys[i], group, i + 1));

这种写法使用了一个立即执行函数表达式(IIFE),这个函数会立即执行并返回一个新的函数。通过这种方式,可以捕获循环中的当前变量状态,并在异步回调中使用。

方式 2:直接传递回调

for (let i = 0; i < 4; i++) {
    let geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100),
        width: 100,
        height: 100,
    };
 
    addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

这种写法直接传递了一个回调函数给addWidgetImgToLayer。通过使用let声明来确保每次循环迭代中创建一个新的块作用域,变量捕获是正确的。

主要区别

变量捕获:

  • 第一种写法通过 IIFE 来捕获当前循环迭代中的变量状态,确保异步回调中使用的是当前迭代的值。
  • 第二种写法直接传递回调,如果使用let声明或其他方法,能正确捕获每次迭代中的变量状态。

代码可读性

  • 第一种写法较为复杂,但能够确保异步回调中的变量正确捕获当前状态。
  • 第二种写法更简洁,但需要确保使用let声明或其他方法正确捕获变量,而不能使用 var(此处使用到的是循环变量i)。

在 JavaScript 中,var声明的变量在函数作用域内是共享的,这意味着在异步回调中,它们的值可能会变成最后一次迭代的值。这会导致我们期望的结果不正确。而let声明的变量在每次循环迭代中都会创建一个新的块作用域,从而确保异步回调中捕获的是当前迭代的值。

示例解释

使用 var 声明的问题:

for (var i = 0; i < 4; i++) {
    const geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100),
        width: 100,
        height: 100,
    };
 
    addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        console.log(i);  // 可能会输出 4,而不是期望的 0, 1, 2, 3,可能在其他位置被修改过了,它们指向同一个地址
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

因为var声明的变量i在函数作用域内是共享的(有点像 Python),所以在异步回调中,i的值可能是循环结束时的值(4),而不是期望的 0, 1, 2, 3。

使用 let 声明解决问题:

for (let i = 0; i < 4; i++) {
    let geometry = {
        x: 100 + (i % 2 === 0 ? 0 : 150),
        y: 50 + (i < 2 ? 0 : 100),
        width: 100,
        height: 100,
    };
 
    addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
        console.log(i);  // 输出期望的 0, 1, 2, 3,使用 let 声明变量不会出现问题
        addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
    });
}

let声明的变量i在每次循环迭代中都会创建一个新的块作用域,因此在异步回调中,i的值是当前迭代的值,确保输出的是期望的 0, 1, 2, 3。

其他捕获变量的方法

另一种确保变量捕获正确的方法是使用立即执行函数表达式(IIFE):

for (var i = 0; i < 4; i++) {
    (function(i) {
        let geometry = {
            x: 100 + (i % 2 === 0 ? 0 : 150),
            y: 50 + (i < 2 ? 0 : 100),
            width: 100,
            height: 100,
        };
 
        addWidgetImgToLayer(geometry, './img/b.png', true, group, 'click', () => {}, () => {
            console.log(i);  // 输出期望的 0, 1, 2, 3,可以理解为使用 IIFE 的话开辟空间事会先对使用到的数据进行了值拷贝
            addShapesToLayer(geometry, 'text', false, group, `${i + 1}`);
        });
    })(i);
}

通过 IIFE,每次循环迭代都会创建一个新的函数作用域,确保异步回调中的变量是当前迭代的值。

在第二种写法中,通过使用let声明或 IIFE,确保异步回调函数中捕获的变量值是当前迭代的值,而不是循环结束后的值。这是确保变量正确捕获和代码正确执行的关键。

结语

在处理 Konva 中的异步加载顺序问题时,确保在图像加载完成后再添加其他元素是关键。通过将回调函数放在imageObj.onload中,并正确处理变量捕获,我们可以确保文本总是绘制在图片之上。这不仅解决了显示顺序的问题,也为未来的调试提供了明确的方向。

「点点赞赏,手留余香」

0

给作者打赏,鼓励TA抓紧创作!

微信微信 支付宝支付宝

还没有人赞赏,快来当第一个赞赏的人吧!

声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系maynote@foxmail.com处理
码云笔记 » Vue 处理异步加载顺序问题:在Konva中确保文本在Konva之上显示

发表回复