先上效果图

功能描述：默认首选标签为第一个“时间”【读者可以根据代码修改默认的标签】，能够增加标签。
点击不同的标签可以进行标签切换。在正文部分能够根据输入的文本txt,或者内置的html文件进行标注，对选中的词语或文段打上标签【体现在背景颜色和文本节点的‘title’属性】。可以再次点击已经标注的内容进行取消标注。最终标注的结果将会以一个对象数组的形式保存，读者可以自行对被标注的内容进行一系列操作。标注结果形如：

Proxy {0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…}, 5: {…}, 6: {…}, 7: {…}, 8: {…}, 9: {…}}
[[Handler]]: Object
[[Target]]: Array(10)
0: {name: '时间', comment: '公铁立交'}
1: {name: '人物', comment: '省道S30'}
2: {name: '颜色', comment: '上部结构'}
3: {name: '颜色', comment: '下部结构'}
4: {name: ' 部位', comment: '中心'}
5: {name: ' 部位', comment: '桩基础'}
6: {name: ' 部位', comment: '层，设置异型钢'}
7: {name: ' 部位', comment: '过各项无损'}
8: {name: ' 部位', comment: '土双柱'}
9: {name: ' 部位', comment: '土空心'}
length: 10
[[Prototype]]: Array(0)
[[IsRevoked]]: false

实现原理

首先：监听鼠标在文本上动作，根据时间间隔来区分是选中了文本？还是只是点击了一下？

    useMouse() {
      let last = new Date().getTime();
        //松开鼠标后，获得时间
      function mousedown() {
        last = new Date().getTime();
      }
      //根据时间间隔判断是选中还是点击事件
      function getMouseEvent() {
        const d = new Date().getTime() - last;
        return d > 200 ? "select" : "click";
      }
      //暴露出的接口
      return {
        mousedown,
        getMouseEvent,
      };
    },

通过对鼠标活动时间的判断，我们可以区分点击和选中这两个动作，显然我们对于点击事件不会做任何处理，需要对选中动作做出一系列操作。

监听既然有了，下一步肯定是选择监听对象了。根据vue生命周期的不同钩子函数所处不同的vue实例状态前提，我们将在vue实例完成对data和methods属性初始化，vDOM挂载到真正得DOM树上后的mounted（）钩子函数中将我们的监听挂载到某个DOM节点上。关于vue生命周期的相关内容这里不多讲，可以参考博客vue生命周期的理解

这里的DOM节点在本文中为正文下所对应的div标签并设置id为text,也是方便通过id获取DOM节点。

    var that = this;
    const ele = document.getElementById("text");
    const { mousedown, getMouseEvent } = this.useMouse();
    /* 中间部分有省略，最终代码请向下看*/
     function mouseup() {
      if (getMouseEvent() !== "select") {
        return;
      }
      else{
      
      }
    ele.addEventListener("mousedown", mousedown);
    ele.addEventListener("mouseup", mouseup);

**再下一步：**我们需要对选中文本做一系列操作。首先应该是能够获得选中文本的信息。这里需要知道的是：
Range 接口表示一个包含节点与文本节点的一部分的文档片段。可以用 Document 对象的 Document.createRange 方法创建 Range，也可以用 Selection 对象的 getRangeAt 方法获取 Range。我们采用 const e = window.getSelection();获得鼠标选中对象。Range中包含了四个属性endContainer，startContainer, startOffset, endOffset。我们通过 const{endContainer,startContainer, startOffset, endOffset } =e.getRangeAt(0);解析出来这四个属性。
他们代表的含义分别是

1. Range.startContainer是只读属性，返回Range开始的节点
2. Range.endContainer 是一个只读属性。它会返回Range对象结束的Node
3. Range.startOffset 是一个只读属性，用于返回一个表示 Range 在 startContainer 中的起始位置的数字。如果 startContainer 是一个文本（Text）、注释（Comment）或者CDATA区块（CDATASection）节点，那么返回的偏移量是从 startContainer 开始到 Range 的边界点的字符数量。对于其他的节点类型， startOffset 返回 startContainer 到边界点的子节点数量。
4. Range.endOffset 返回代表 Range 结束位置在 Range.endContainer 中的偏移值的数字。**如果 endContainer 的 Node 类型为 Text, Comment，或 CDATASection，偏移值是 endContainer 节点开头到 Range 末尾的总字符个数。**对其他类型的 Node ， endOffset 指 endContainer 开头到 Range 末尾的总 Node 个数。

为了便于理解这四个属性值，请看下面图例


可以对比得知，我们标注的内容【文本节点】,startContainer和endContainer 为其父结点，startOffset 为从父结点开始到range对象开始的字符偏移，endOffset 为从父结点开始到range对象结束的偏移，两者相减等于标注对象的字符数量。

上一步我们获得了选中对象range相对于父结点的位置。那么我们怎么在整个文本节点中获得代操作的标注对象呢？我们首先通过遍历根结点id="text"下的子节点，

    cutrrentNodes() {
      function getNodes(ele, count = { value: 0 }) {
        const list = [];
        const items = ele.childNodes;
        for (let index in items) {
          const _item = items[index];
          if (_item.nodeName === "#text") {
            const item = _item;
            const value = item.nodeValue || "";
            const len = value.length;
            list.push({
              item,
              index: +index,
              len,
              value,
            });
            count.value += len;
          } else {
            list.push(...getNodes(_item, count));
          }
        }
        return list;
      }
      return {
        getNodes,
      };
    },

通过findIndex()搜索，我们可以得到包含标签结点的父结点在根结点的孩子结点的数组中的索引。需要注意的是getNodes的返回值是**每一次操作之前的孩子结点数组。**这是由于我们标签修改节点生效的操作在查询之前导致的，并不是错误。

          const nodes = getNodes(ele);
          const start = nodes.findIndex((x) => x.item === startContainer);
          const end = nodes.findIndex((x) => x.item === endContainer);

注：-1表示没有找到，其他值表示对应所处数组的下标值。

startContainer和endContainer相同的情况即没有重叠的情况下 比较理想化的情况，不存在语义标签重叠和多语义元素，这也是我们的不足之处

          if (start > -1 && end > -1) {
           //startContainer和endContainer相同的情况即没有重叠的情况下  比较理想化的情况，不存在语义标签重叠和多语义元素
            if (start === end) {
              const { item, value } = nodes[start];
              const left = getText(value.slice(0, startOffset));
              const center = getSpan(value.slice(startOffset, endOffset));
              const right = getText(value.slice(endOffset));
              item.parentNode?.insertBefore(left, item);
              item.parentNode?.insertBefore(center, item);
              item.parentNode?.insertBefore(right, item);
              item.parentNode?.removeChild(item);
            } else {
            //不相同的情况处理：
              for (let i = start; i <= end; i++) {
                const { item, value } = nodes[i];
                if (i === start) {
                  const left = getText(value.slice(0, startOffset));
                  const right = getSpan(value.slice(startOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else if (i === end) {
                  const left = getSpan(value.slice(0, endOffset));
                  const right = getText(value.slice(endOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else {
                  item.parentNode?.replaceChild(getSpan(value), item);
                }
              }
            }
          }

比较重要的函数是getSpan()和getText（）

    function getText(text) {
      return document.createTextNode(text);
    }

getText(text)方法的作用是创建并返回一个内容为text(参数)的文本节点。 我们这么做的原因可以参照下图来理解：选中某一文本片段后，【文本内容是根据之前的偏移量进行截取的】我们将该节点分割成三个文本重新装回DOM树，左右两侧不添加特殊标签，选中的文本我们给节点外加span标签方便添加样式。

             //以这一段为例将节点分成三份
              const left = getText(value.slice(0, startOffset));
              const center = getSpan(value.slice(startOffset, endOffset));
              const right = getText(value.slice(endOffset));

    function getSpan(text) {
      const span = document.createElement("span");
      //span.classList.add("mytest");
      //设置节点背景颜色
      span.style.backgroundColor = that.dynamicTags[that.selectedIndex].color;
      //设置节点的title属性，并赋予对应标签名
      span.setAttribute("title", that.dynamicTags[that.selectedIndex].name);
      let tempText = Object();
      tempText.name = that.dynamicTags[that.selectedIndex].name;
      tempText.comment = text;
      that.addTagText(tempText);
      span.addEventListener("click", function ($event) {
        let tempText = Object();
        tempText.name = that.dynamicTags[that.selectedIndex].name;
        tempText.comment = this.innerText;
        that.deleteTagText(tempText);
        console.log(that.showSelectedText());
        var temp = document.createTextNode(this.innerText);
        var sour = $event.currentTarget;
        sour.parentNode.replaceChild(temp, sour);
        ele.normalize();
      });
      span.innerText = text.replace(/\n/g, "");
      return span;
    }

getSpan（text）方法中参数是我们选中的标签文本内容，我们需要再增加的操作包括，对该文本节点附带上我们所选的标签的背景颜色，并绑定title属性为标签名。

data中存放的标签类型和当前选中标签索引：
dynamicTags: [
{
name: “时间”,
color: “red”,
},
{
name: “人物”,
color: “yellow”,
},
{
name: “天气”,
color: “blue”,
},
],
selectedIndex: 0,

利用上述两个数据变量，可以实现对选中文本改为span标签下的文本节点，并添加上样式属性。后面就是通过对新的文本节点绑定监听再次点击事件，用于删除节点样式回复到未操作前的状态。在监听事件中我们简单（深拷贝）复制一遍节点信息【内容和节点标签名】。然后在我们选中的所有标签容器中找到对应项并删除，内部通过replaceChild（）替换掉即可。最后也是官方提供的方法，多个文本节点在渲染上是看不出的，但是你通过F12可以查看源码为分割的片段，他们在DOM树上是兄弟关系。还是结合下图来理解，虽然你返还了选中内容，在外表上没有区别，但是他们依然是分割成3个片段而不是一个整体。为解决这个问题，我们使用了 ele.normalize();

注意：replaceChild（）是通过当前选中的节点的父结点来执行的！ normalize()，其作用是处理文档树中的文本节点。当在某个节点上调用这个方法时，就会在该节点的后代节点中查找。如果找到了空文本节点，则删除它；如果找到相邻的文本节点，则将它们合并为一个文本节点。

最后就是抽出我们选中的文本进行操作：

    //选中好的文本添加到数组中
    addTagText(tempText) {
      this.selectedText.push(tempText);
    },

    deleteTagText(tempText) {
      // 先找到
      const deleteIndex = this.selectedText.findIndex((item) => {
        // 不写return返回的是-1，谜
        return item.comment === tempText.comment;
      });
      console.log(deleteIndex); // 2
      this.selectedText.splice(deleteIndex, 1);
    },
    showSelectedText() {
      return this.selectedText;
    },

整体代码（html通过iframe本地引用）

代码略微修改，样式太难看了，就小动了一下。关于iframe的使用需要注意的是路径问题，如果是本地存储则静态html文件应该在public目录下，如果是网络资源加载请确保具有读权限和在线预览。

    <!-- 文本框 -->
    <div id="text" >
     <iframe src="/html/test2.html" height="500px" width="100%"></iframe>
    </div>

<template>
  <div class="card">
    <!-- 标签值单选框-->
    <div class="container" >
      <el-tag
        :key="tag"
        v-for="(tag, index) in dynamicTags"
        closable
        :disable-transitions="false"
        @close="handleClose(tag)"
        @click="selectTag(tag, index)"
        :color="tag.color"
      >
        {{ tag.name }}
      </el-tag>
      <el-input
        class="input-new-tag"
        v-if="inputVisible"
        v-model="inputValue"
        ref="saveTagInput"
        size="small"
        @keyup.enter="handleInputConfirm"
        @blur="handleInputConfirm"
      >
      </el-input>
      <el-button v-else class="button-new-tag" size="small" @click="showInput"
        >+ New Tag</el-button
      >
    </div>
    <el-divider content-position="center">正文</el-divider>
    <!-- 文本框 -->
    <div id="text" >
     <iframe src="/html/test2.html" height="500px" width="100%"></iframe>
    </div>

  </div>
</template>


<script>
export default {
  // 数据源
  data() {
    return {
      color1: "#409EFF",
      dynamicTags: [
        {
          name: "时间",
          color: "red",
        },
        {
          name: "人物",
          color: "yellow",
        },
        {
          name: "天气",
          color: "blue",
        },
      ],
      selectedIndex: 0,
      inputVisible: false,
      inputValue: "",
      selectedText: [],
    };
  },
  //生命周期函数---
  mounted() {
    var that = this;
    const ele = document.getElementById("text");
    const { mousedown, getMouseEvent } = that.useMouse();
    const { getNodes } = that.cutrrentNodes();
    var index = that.getSelectTag();
    function getSpan(text) {
      const span = document.createElement("span");
     // span.classList.add("mytest");
      span.style.backgroundColor = that.dynamicTags[that.selectedIndex].color;
      span.setAttribute("title", that.dynamicTags[that.selectedIndex].name);
      let tempText = Object();
      tempText.name = that.dynamicTags[that.selectedIndex].name;
      tempText.comment = text;
      that.addTagText(tempText);
      span.addEventListener("click", function ($event) {
        let tempText = Object();
        tempText.name = that.dynamicTags[that.selectedIndex].name;
        tempText.comment = this.innerText;
        that.deleteTagText(tempText);
        // console.log(that.showSelectedText());
        var temp = document.createTextNode(this.innerText);
        var sour = $event.currentTarget;
        sour.parentNode.replaceChild(temp, sour);
        ele.normalize();
      });
      span.innerText = text.replace(/\n/g, "");
      return span;
    }
    function getText(text) {
      return document.createTextNode(text);
    }
    function mouseup() {
      if (getMouseEvent() !== "select") {
        return;
      }
      const e = window.getSelection();
      console.log(e)
      if (e && e.type === "Range") {
        try {
          const { endContainer, startContainer, startOffset, endOffset } =
            e.getRangeAt(0);
          const nodes = getNodes(ele);
          const start = nodes.findIndex((x) => x.item === startContainer);
          const end = nodes.findIndex((x) => x.item === endContainer);
          if (start > -1 && end > -1) {
            if (start === end) {
              const { item, value } = nodes[start];
              const left = getText(value.slice(0, startOffset));
              const center = getSpan(value.slice(startOffset, endOffset));
              const right = getText(value.slice(endOffset));
              item.parentNode?.insertBefore(left, item);
              item.parentNode?.insertBefore(center, item);
              item.parentNode?.insertBefore(right, item);
              item.parentNode?.removeChild(item);
            } else {
              for (let i = start; i <= end; i++) {
                const { item, value } = nodes[i];
                if (i === start) {
                  const left = getText(value.slice(0, startOffset));
                  const right = getSpan(value.slice(startOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else if (i === end) {
                  const left = getSpan(value.slice(0, endOffset));
                  const right = getText(value.slice(endOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else {
                  item.parentNode?.replaceChild(getSpan(value), item);
                }
              }
            }
          }
        } catch (error) {
          console.error(error);
        } finally {
          e.removeAllRanges();
        }
      }
    }
    ele.addEventListener("mousedown", mousedown);
    ele.addEventListener("mouseup", mouseup);
  },
  //基本方法
  methods: {
    handleClose(tag) {
      this.dynamicTags.splice(this.dynamicTags.indexOf(tag), 1);
    },
    showInput() {
      this.inputVisible = true;
      this.$nextTick((_) => {
        this.$refs.saveTagInput.$refs.input.focus();
      });
    },
    handleInputConfirm() {
      let inputValue = new Object();
      inputValue.name = this.inputValue;
      inputValue.color = this.rdmRgbColor();
      if (inputValue) {
        this.dynamicTags.push(inputValue);
      }
      this.inputVisible = false;
      this.inputValue = " ";
    },
    //选中标签
    selectTag(tag, index) {
      ElMessage({
        message: "当前标签为：" + tag.name,
        type: "success",
      });
      this.selectedIndex = index;
    },
    getSelectTag() {
      return this.selectedIndex;
    },
    //所有色
    rdmRgbColor() {
      //随机生成RGB颜色
      let arr = [];
      for (var i = 0; i < 3; i++) {
        arr.push(Math.floor(Math.random() * 256));
      }
      let [r, g, b] = arr;
      // rgb颜色
      // var color=`rgb(${r},${g},${b})`;
      // 16进制颜色
      var color = `#${
        r.toString(16).length > 1 ? r.toString(16) : "0" + r.toString(16)
      }${g.toString(16).length > 1 ? g.toString(16) : "0" + g.toString(16)}${
        b.toString(16).length > 1 ? b.toString(16) : "0" + b.toString(16)
      }`;
      return color;
    },
    // 监听鼠标动作判断
    useMouse() {
      let last = new Date().getTime();
      function mousedown() {
        last = new Date().getTime();
      }
      function getMouseEvent() {
        const d = new Date().getTime() - last;
        return d > 200 ? "select" : "click";
      }
      return {
        mousedown,
        getMouseEvent,
      };
    },
    cutrrentNodes() {
      function getNodes(ele, count = { value: 0 }) {
        const list = [];
        const items = ele.childNodes;
        for (let index in items) {
          const _item = items[index];
          if (_item.nodeName === "#text") {
            const item = _item;
            const value = item.nodeValue || "";
            const len = value.length;
            list.push({
              item,
              index: +index,
              len,
              value,
            });
            count.value += len;
          } else {
            list.push(...getNodes(_item, count));
          }
        }
        return list;
      }
      return {
        getNodes,
      };
    },

    getTags() {
      return this.dynamicTags;
    },
    //选中好的文本添加到数组中
    addTagText(tempText) {
      this.selectedText.push(tempText);
    },

    deleteTagText(tempText) {
      // 先找到
      const deleteIndex = this.selectedText.findIndex((item) => {
        // 不写return返回的是-1，谜
        return item.comment === tempText.comment;
      });
      console.log(deleteIndex); // 2
      this.selectedText.splice(deleteIndex, 1);
    },
    showSelectedText() {
      return this.selectedText;
    },
  },
  //计算类型方法和其他方法的区别：有缓存。以内存换时间，适用于频繁使用的计算
  computed: {},
};
</script>

<style  lang="scss" scoped>
.card {
  width: 600px;
 
  margin: 0 auto; /* 这里的0表示上面边距，左右边距需要设置为auto才能水平居中 */
  padding-top: 50px;
  padding-bottom: 50px;
}
.container {
  display: flex;
  align-items: center;
  justify-content: center;
  height: 100px;
}
.el-tag + .el-tag {
  margin-left: 10px;
}
.button-new-tag {
  margin-left: 10px;
  height: 32px;
  line-height: 30px;
  padding-top: 0;
  padding-bottom: 0;
}
.input-new-tag {
  width: 90px;
  margin-left: 10px;
  vertical-align: bottom;
}

</style>

整体代码（html文件直接在页面中）

<template>
  <div class="card">
    <!-- 标签值单选框-->
    <div class="container" >
      <el-tag
        :key="tag"
        v-for="(tag, index) in dynamicTags"
        closable
        :disable-transitions="false"
        @close="handleClose(tag)"
        @click="selectTag(tag, index)"
        :color="tag.color"
      >
        {{ tag.name }}
      </el-tag>
      <el-input
        class="input-new-tag"
        v-if="inputVisible"
        v-model="inputValue"
        ref="saveTagInput"
        size="small"
        @keyup.enter="handleInputConfirm"
        @blur="handleInputConfirm"
      >
      </el-input>
      <el-button v-else class="button-new-tag" size="small" @click="showInput"
        >+ New Tag</el-button
      >
    </div>
    <el-divider content-position="center">正文</el-divider>
    <!-- 文本框 -->
    <div style=" overflow-y: auto; -webkit-overflow-scrolling: touch; white-space: nowrap; width: 100%; height: 530px;">
    <div id="text" >
      <p><a id="_Toc467345721"></a></p>
      <h1>
        <a id="报告标题A"></a><a id="_Toc342212070"></a
        ><a id="_Toc361148894"></a><a id="_Toc487438895"></a
        ><a id="_Toc342212083"></a><a id="_Toc341261013"></a
        ><a id="_Toc181668622"></a><a id="_Toc101548670"></a>概况
      </h1>
      <h2><a id="_Toc487438896"></a><a id="_Toc101548671"></a>桥梁概况</h2>
      <p>
        太西公铁立交桥位于省道S301。路线技术等级为二级，桥梁中心桩号为K39+319，设计荷载等级为公路-I级，2008年建成通车。
      </p>
      <p>桥梁全长245.2m，共12跨。桥梁全宽12.50m，现阶段桥梁未设置限重标志。</p>
      <p>
        上部结构：12×20m预应力混凝土空心板梁，支座类型为板式橡胶支座,伸缩缝为4道异型钢伸缩缝，第6跨为下跨铁路。
      </p>
      <p>
        下部结构：钢筋混凝土双柱框架式桥墩、桩基础；钢筋混凝土埋入式桥台、桩基础。
      </p>
      <p>桥面系：沥青混凝土铺装层，设置异型钢伸缩缝装置。</p>
      <p>
        受宁夏公路管理局的委托，中铁大桥科学研究院有限公司于2017年6月24日对太西公铁立交桥进行了定期检查。
      </p>
      <p>桥梁地理位置图如所示，桥梁现阶段正、立面照如所示。</p>
      <img
        src="data:image/png;base64,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"
      />
      <p><a id="_Ref467309844"></a>图 ‑1 桥梁地理位置图</p>
      <h2>
        <a id="_Toc487438897"></a><a id="_Toc101548672"></a>上次检测及维修情况
      </h2>
      <p>未搜集到上次检测报告。</p>
      <h2><a id="_Toc487438898"></a><a id="_Toc101548673"></a>检测目的</h2>
      <p>通过对桥梁的全面检查，达到下列目的：</p>
      <p>
        （1）通过对桥梁缺损和病害的调查，记录其位置、大小、范围和程度，全面掌握桥梁运营现状，评定桥梁的使用功能。
      </p>
      <p>
        （2）通过各项无损检测，掌握桥梁主要构件的材质状况，对桥梁结构的耐久性和受力性能进行综合分析和评价。
      </p>
      <p>
        （3）通过检查和检测，分析桥梁主要病害产生的原因，判断病害的性质、发展趋势及对桥梁承载能力、耐久性和使用性能的影响程度，提出需进行特殊检查的项目，并对桥梁病害提出处治建议。
      </p>
      <p>
        （4）对桥梁技术状况进行综合评定，更新和完善桥梁管理系统数据库，为桥梁日后的养护管理、维修加固设计提供依据。
      </p>
      <h2><a id="_Toc487438899"></a><a id="_Toc101548674"></a>检测依据</h2>
      <p>（1）《公路桥梁技术状况评定标准》（JTG/T H21-2011）；</p>
      <p>（2）《公路桥涵养护规范》（JTG H11-2004）；</p>
      <p>（3）《公路桥梁承载能力检测评定规程》（JTG/T J21-2011）；</p>
      <p>（4）《公路桥涵设计通用规范》（JTG D60-2004、JTG D60-2015）；</p>
      <p>（5）《公路钢筋混凝土及预应力混凝土桥涵设计规范》（JTG D62-2004）；</p>
      <p>（6）《公路桥涵地基与基础设计规范》（JTG D63-2007）；</p>
      <p>
        （7）《<a href="http://www.docin.com/p-248286935.html"
          >回弹法检测混凝土抗压强度技术规程</a
        >》（JGJ/T 23-2011）；
      </p>
      <p>（8）《混凝土中钢筋检测技术规程》（JGJ/T 152-2008）；</p>
      <p>（9）《公路桥梁板式橡胶支座技术标准》JT/T 4-2004</p>
      <p>（10）《公路桥梁伸缩缝装置》 JTT 327-2004</p>
      <p>(11)《公路养护安全作业规程》（JTG H30-2004）；</p>
      <p>（12）桥梁施工、设计、竣工资料及养护、维修、加固资料；</p>
      <p>（13）检测项目招、投标及合同文件。</p>
      <h1>
        <a id="_Toc487438902"></a
        ><a id="_Toc101548675"></a>桥梁部件、构件划分及编号
      </h1>
      <h2>
        <a id="_Toc487438903"></a><a id="_Toc101548676"></a>构件划分及数量
      </h2>
      <p>
        根据桥梁结构特点，参照《公路桥梁技术状况评定标准》（JTG/T
        H21-2011），该桥部件划分及构件数量见。
      </p>
      <p><a id="_Ref466586631"></a>表‑1 桥梁部件划分及构件数量表</p>
      <table>
        <thead>
          <tr>
            <th>
              <p><strong>序号</strong></p>
            </th>
            <th>
              <p><strong>桥梁结构</strong></p>
            </th>
            <th>
              <p><strong>桥梁部件</strong></p>
            </th>
            <th>
              <p><strong>构件数量</strong></p>
            </th>
            <th>
              <p><strong>备注</strong></p>
            </th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><p>1</p></td>
            <td rowspan="3"><p>上部结构</p></td>
            <td><p>上部承重构件</p></td>
            <td><p>132</p></td>
            <td><p>空心板梁</p></td>
          </tr>
          <tr>
            <td><p>2</p></td>
            <td><p>上部一般构件</p></td>
            <td><p>120</p></td>
            <td><p>铰缝</p></td>
          </tr>
          <tr>
            <td><p>3</p></td>
            <td><p>支座</p></td>
            <td><p>528</p></td>
            <td><p>板式橡胶支座</p></td>
          </tr>
          <tr>
            <td><p>4</p></td>
            <td rowspan="7"><p>下部结构</p></td>
            <td><p>翼墙、耳墙</p></td>
            <td><p>4</p></td>
            <td><p>/</p></td>
          </tr>
          <tr>
            <td><p>5</p></td>
            <td><p>锥坡、护坡</p></td>
            <td><p>6</p></td>
            <td><p>4个锥坡，2个护坡</p></td>
          </tr>
          <tr>
            <td><p>6</p></td>
            <td><p>桥墩</p></td>
            <td><p>44</p></td>
            <td><p>22根墩柱，11片盖梁，,11个系梁</p></td>
          </tr>
          <tr>
            <td><p>7</p></td>
            <td><p>桥台</p></td>
            <td><p>4</p></td>
            <td><p>2个台身，2个台帽</p></td>
          </tr>
          <tr>
            <td><p>8</p></td>
            <td><p>墩台基础</p></td>
            <td><p>24</p></td>
            <td><p>桩基础</p></td>
          </tr>
          <tr>
            <td><p>9</p></td>
            <td><p>河床</p></td>
            <td><p>/</p></td>
            <td><p>/</p></td>
          </tr>
          <tr>
            <td><p>10</p></td>
            <td><p>调治构造物</p></td>
            <td><p>/</p></td>
            <td><p>/</p></td>
          </tr>
          <tr>
            <td><p>11</p></td>
            <td rowspan="6"><p>桥面系</p></td>
            <td><p>桥面铺装</p></td>
            <td><p>1</p></td>
            <td><p>沥青混凝土</p></td>
          </tr>
          <tr>
            <td><p>12</p></td>
            <td><p>伸缩缝装置</p></td>
            <td><p>4</p></td>
            <td><p>异型钢伸缩缝</p></td>
          </tr>
          <tr>
            <td><p>13</p></td>
            <td><p>人行道</p></td>
            <td><p>/</p></td>
            <td><p>/</p></td>
          </tr>
          <tr>
            <td><p>14</p></td>
            <td><p>栏杆、护栏</p></td>
            <td><p>2</p></td>
            <td><p>/</p></td>
          </tr>
          <tr>
            <td><p>15</p></td>
            <td><p>排水系统</p></td>
            <td><p>1</p></td>
            <td><p>泄水孔</p></td>
          </tr>
          <tr>
            <td><p>16</p></td>
            <td><p>照明、标志</p></td>
            <td><p>1</p></td>
            <td><p>标志</p></td>
          </tr>
        </tbody>
      </table>
    </div>
    </div>
  </div>
</template>


<script>
export default {
  // 数据源
  data() {
    return {
      color1: "#409EFF",
      dynamicTags: [
        {
          name: "时间",
          color: "red",
        },
        {
          name: "人物",
          color: "yellow",
        },
        {
          name: "天气",
          color: "blue",
        },
      ],
      selectedIndex: 0,
      inputVisible: false,
      inputValue: "",
      selectedText: [],
    };
  },
  //生命周期函数---
  mounted() {
    var that = this;
    const ele = document.getElementById("text");
    const { mousedown, getMouseEvent } = this.useMouse();
    const { getNodes } = this.cutrrentNodes();
    var index = this.getSelectTag();
    function getSpan(text) {
      const span = document.createElement("span");
     // span.classList.add("mytest");
      span.style.backgroundColor = that.dynamicTags[that.selectedIndex].color;
      span.setAttribute("title", that.dynamicTags[that.selectedIndex].name);
      let tempText = Object();
      tempText.name = that.dynamicTags[that.selectedIndex].name;
      tempText.comment = text;
      that.addTagText(tempText);
      span.addEventListener("click", function ($event) {
        let tempText = Object();
        tempText.name = that.dynamicTags[that.selectedIndex].name;
        tempText.comment = this.innerText;
        that.deleteTagText(tempText);
        console.log(that.showSelectedText());
        var temp = document.createTextNode(this.innerText);
        var sour = $event.currentTarget;
        sour.parentNode.replaceChild(temp, sour);
        ele.normalize();
      });
      span.innerText = text.replace(/\n/g, "");
      return span;
    }
    function getText(text) {
      return document.createTextNode(text);
    }
    function mouseup() {
      if (getMouseEvent() !== "select") {
        return;
      }
      const e = window.getSelection();
      console.log(e)
      if (e && e.type === "Range") {
        try {
          const { endContainer, startContainer, startOffset, endOffset } =
            e.getRangeAt(0);
          const nodes = getNodes(ele);
          const start = nodes.findIndex((x) => x.item === startContainer);
          const end = nodes.findIndex((x) => x.item === endContainer);
          if (start > -1 && end > -1) {
            if (start === end) {
              const { item, value } = nodes[start];
              const left = getText(value.slice(0, startOffset));
              const center = getSpan(value.slice(startOffset, endOffset));
              const right = getText(value.slice(endOffset));
              item.parentNode?.insertBefore(left, item);
              item.parentNode?.insertBefore(center, item);
              item.parentNode?.insertBefore(right, item);
              item.parentNode?.removeChild(item);
            } else {
              for (let i = start; i <= end; i++) {
                const { item, value } = nodes[i];
                if (i === start) {
                  const left = getText(value.slice(0, startOffset));
                  const right = getSpan(value.slice(startOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else if (i === end) {
                  const left = getSpan(value.slice(0, endOffset));
                  const right = getText(value.slice(endOffset));
                  item.parentNode?.insertBefore(left, item);
                  item.parentNode?.insertBefore(right, item);
                  item.parentNode?.removeChild(item);
                } else {
                  item.parentNode?.replaceChild(getSpan(value), item);
                }
              }
            }
          }
        } catch (error) {
          console.error(error);
        } finally {
          e.removeAllRanges();
        }
      }
    }
    ele.addEventListener("mousedown", mousedown);
    ele.addEventListener("mouseup", mouseup);
  },
  //基本方法
  methods: {
    handleClose(tag) {
      this.dynamicTags.splice(this.dynamicTags.indexOf(tag), 1);
    },
    showInput() {
      this.inputVisible = true;
      this.$nextTick((_) => {
        this.$refs.saveTagInput.$refs.input.focus();
      });
    },
    handleInputConfirm() {
      let inputValue = new Object();
      inputValue.name = this.inputValue;
      inputValue.color = this.rdmRgbColor();
      if (inputValue) {
        this.dynamicTags.push(inputValue);
      }
      this.inputVisible = false;
      this.inputValue = " ";
    },
    //选中标签
    selectTag(tag, index) {
      ElMessage({
        message: "当前标签为：" + tag.name,
        type: "success",
      });
      this.selectedIndex = index;
    },
    getSelectTag() {
      return this.selectedIndex;
    },
    //所有色
    rdmRgbColor() {
      //随机生成RGB颜色
      let arr = [];
      for (var i = 0; i < 3; i++) {
        arr.push(Math.floor(Math.random() * 256));
      }
      let [r, g, b] = arr;
      // rgb颜色
      // var color=`rgb(${r},${g},${b})`;
      // 16进制颜色
      var color = `#${
        r.toString(16).length > 1 ? r.toString(16) : "0" + r.toString(16)
      }${g.toString(16).length > 1 ? g.toString(16) : "0" + g.toString(16)}${
        b.toString(16).length > 1 ? b.toString(16) : "0" + b.toString(16)
      }`;
      return color;
    },
    // 监听鼠标动作判断
    useMouse() {
      let last = new Date().getTime();
      function mousedown() {
        last = new Date().getTime();
      }
      function getMouseEvent() {
        const d = new Date().getTime() - last;
        return d > 200 ? "select" : "click";
      }
      return {
        mousedown,
        getMouseEvent,
      };
    },
    cutrrentNodes() {
      function getNodes(ele, count = { value: 0 }) {
        const list = [];
        const items = ele.childNodes;
        for (let index in items) {
          const _item = items[index];
          if (_item.nodeName === "#text") {
            const item = _item;
            const value = item.nodeValue || "";
            const len = value.length;
            list.push({
              item,
              index: +index,
              len,
              value,
            });
            count.value += len;
          } else {
            list.push(...getNodes(_item, count));
          }
        }
        return list;
      }
      return {
        getNodes,
      };
    },

    getTags() {
      return this.dynamicTags;
    },
    //选中好的文本添加到数组中
    addTagText(tempText) {
      this.selectedText.push(tempText);
    },

    deleteTagText(tempText) {
      // 先找到
      const deleteIndex = this.selectedText.findIndex((item) => {
        // 不写return返回的是-1，谜
        return item.comment === tempText.comment;
      });
      console.log(deleteIndex); // 2
      this.selectedText.splice(deleteIndex, 1);
    },
    showSelectedText() {
      return this.selectedText;
    },
  },
  //计算类型方法和其他方法的区别：有缓存。以内存换时间，适用于频繁使用的计算
  computed: {},
};
</script>

<style  lang="scss" scoped>
.card {
  width: 600px;
  height: 600px;
  margin: 0 auto; /* 这里的0表示上面边距，左右边距需要设置为auto才能水平居中 */
  padding-top: 50px;
  padding-bottom: 50px;
}
.container {
  display: flex;
  align-items: center;
  justify-content: center;
  height: 100px;
}
.el-tag + .el-tag {
  margin-left: 10px;
}
.button-new-tag {
  margin-left: 10px;
  height: 32px;
  line-height: 30px;
  padding-top: 0;
  padding-bottom: 0;
}
.input-new-tag {
  width: 90px;
  margin-left: 10px;
  vertical-align: bottom;
}

.text {
  padding-top: 40px;
}
</style>

不足之处

1. 没有实现标签嵌套，不能在一个标签标注的内容内再标注其他标签。
2. 后面将会单独整理出一个小Demo,放到gitee上供大家访问。

鸣谢

https://segmentfault.com/q/1010000041593766/a-1020000041595409