tml文件即超文本标记语言文件文档，是扩展名、后缀名为html的文件。超文本标记语言的结构包括头部分（Head）、和主体部分（Body），其中头部（head）提供关于网页的信息，主体（body）部分提供网页的具体内容。html文件能够被多种网页浏览器读取，传递。我们可以使用电脑上自带的记事本进行编辑htm文件。那么html文件删除如何恢复？

通常情况下当您从电脑存储设备中删除html文件时，该html文件会保存在回收站中。 可以根据需要通过单击还原选项将其还原。 但是不好运的情况下，如果您清空回收站或文件未经过回收站、或使用永久删除键Shift + Delete将文件删除怎么恢复呢？我们可以通过使用数据恢复软件来恢复。

html文件删除恢复步骤如下:

1、首先到官网下载并安装好云骑士数据恢复软件（注意：软件不能安装在丢失盘中），打开云骑士数据恢复软件，根据需要选择恢复功能，这里选择场景模式下的误删除文件。

2、选择好以后选择需要恢复数据的分区，如果是外接设备则可以将它插入电脑中，或者通过读卡器插入电脑，点击开始扫描。

3、扫描结束以后，你会发现有很多数据，这时我们可以通过文件类型进行查找，这里勾选其他文件类型，然后找到了需要的html格式文件。

因为文件丢失后有可能会因各种原因受损，所以遵循先预览再恢复原则，通过预览模式判断文件是否正常再进行恢复。对于无法预览或者不支持预览的是无法判断数据是好的还是坏的，只能恢复出来才能进行查看的。

4、接着在需要恢复的html文件前面进行勾选，选择好以后点击立即恢复按钮。

5、弹出设置文件路径窗口，将文件存储在安全区域中（如果存储盘不够内存，可以外接其他设备进行存储），点击确定按钮。

6、耐心等待文件导出完成，点击查看即可查看恢复出来的html文件了。

知识普及：

导致html文件丢失常见几种原因：

采用来源于Internet的各种各样没经验证的第三方应用程序也许会使您的html文件遭遇风险。

偶尔在下载那些应用程序时，某些恶意病毒也许会进入系统并破坏html文件结构，亦或它们也许会删除桌面上的所有html文件，因此致使大量数据丢失。

在重新分区或调整硬盘大小时，那些html文件也许会遗失。在重新分区时，一个重大的错误也会删除存储了所必需文件的分区，例如DOC、PPT、XLSX和HTML。

总结：以上就是html文件删除恢复教程了，如果在软件使用过程中有不懂的问题，可以咨询专业的在线客服人员为您解答~

本文来自 yqssjhf.com>> 创作不易，转载请注明出处。

常扒别人网站文章的坑们；我是指那种批量式采集的压根不看内容的；少不了都会用到删除html标签的函数；这里介绍3种不同用途上的方法；

$str='<div><p>这里是p标签</p><img src="" alt="这里是img标签"><a href="">这里是a标签</a><br></div>';

1：删除全部或者保留指定html标签php自带的函数strip_tags即可满足要求，使用方法：strip_tags(string,allow)；string：需要处理的字符串；allow：需要保留的指定标签，可以写多个；

echo strip_tags($str,'<p><a>');//输出：<p>这里是p标签</p><a href="">这里是a标签</a>

此函数的优点是简单粗暴；但是缺点也很明显；如果有一大堆标签；而我只是想删除指定的某一个；那要写很多需要保留的标签；所以有了第二个方法；

2：删除指定的html标签使用方法：strip_html_tags($tags,$str)；$tags：需要删除的标签(数组格式)$str：需要处理的字符串；

function strip_html_tags($tags,$str){
    $html=array();
    foreach ($tags as $tag) {
        $html[]="/(<(?:\/".$tag."|".$tag.")[^>]*>)/i";
    }
    $data=preg_replace($html, '', $str);
    return $data;
}
echo strip_html_tags(array('p','img'),$str);
//输出：<div>这里是p标签<a href="">这里是a标签</a><br></div>;

3：删除标签和标签的内容使用方法：strip_html_tags($tags,$str)；$tags：需要删除的标签(数组格式)$str：需要处理的字符串；

function strip_html_tags($tags,$str){
    $html=array();
    foreach ($tags as $tag) {
        $html[]='/<'.$tag.'.*?>[\s|\S]*?<\/'.$tag.'>/';
        $html[]='/<'.$tag.'.*?>/';
    }
    $data=preg_replace($html,'',$str);
    return $data;
}
echo strip_html_tags(array('a','img'),$str);
//输出<div><p>这里是p标签</p><br></div>

很多网站文章里面会带上网站名和链接；这个函数就是专治这种；别拿这个函数采集本站啊；不然保证不打死你；4：终极函数，删除指定标签；删除或者保留标签内的内容；使用方法：strip_html_tags($tags,$str,$content)；$tags：需要删除的标签(数组格式)$str：需要处理的字符串；$ontent：是否删除标签内的内容 0保留内容 1不保留内容

日常编程中，我们经常会遇到数组去重的问题。今天，我们就来聊聊如何用JavaScript来优雅地解决这个问题。

问题描述

给定一个包含重复元素的数组，我们希望创建一个新的数组，其中只包含原始数组中的唯一值。例如，如果我们有一个数组 [1, 2, 3, 2, 4, 1, 5]，期望的输出应该是 [1, 2, 3, 4, 5]。

方法一：最原始的方法

我们可以使用最简单的方法——嵌套循环来解决这个问题。遍历每一个元素，检查它是否已经存在于新数组中，如果不存在则添加进去。

function removeDuplicates(arr) {
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    let isDuplicate = false;
    for (let j = 0; j < result.length; j++) {
      if (arr[i] === result[j]) {
        isDuplicate = true;
        break;
      }
    }
    if (!isDuplicate) {
      result.push(arr[i]);
    }
  }
  return result;
}
const myArray = [1, 2, 3, 2, 4, 1, 5];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

这个方法虽然直观，但当数组很大时，效率会变得非常低，因为时间复杂度是 O(n²)。

方法二：使用indexOf和filter方法

我们还可以使用 indexOf 方法配合 filter 方法来去重，这样看起来会简洁不少。

function removeDuplicates(arr) {
  return arr.filter((item, pos) => arr.indexOf(item) === pos);
}
const myArray = [1, 2, 3, 2, 4, 1, 5];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

在这个方法中，我们使用 filter 方法创建了一个新数组，只有满足条件的元素才会被包含进来。条件是当前元素的索引应该等于该元素在数组中第一次出现的位置。这种方法代码看起来更简洁，但是它的时间复杂度依然是 O(n²)，因为 indexOf 需要遍历整个数组来查找元素的位置。

使用对象特性优化

在处理大数组去重时，我们可以利用对象的特性来提升性能。通过在对象中记录数组元素，可以有效减少重复元素的检查次数。

function removeDuplicates(arr) {
  const seen = {};
  return arr.filter((item) => {
    if (seen[item]) {
      return false;
    } else {
      seen[item] = true;
      return true;
    }
  });
}
const myArray = [1, 2, 3, 2, 4, 1, 5];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

这个方法创建了一个空对象 seen，然后通过 filter 方法遍历数组。每个元素都会检查是否已存在于 seen 对象中。如果存在，则跳过；否则，加入 seen 对象并保留在新数组中。这种方法对于大数组更高效，但存在一些缺点：

• 类型转换：对象键只能是字符串或符号，这导致数字和字符串形式的数字无法区分。例如，removeDuplicates([1, "1"]) 会返回 [1]。
• 对象相等性：所有对象在这个解决方案中被认为是相等的。例如，removeDuplicates([{foo: 1}, {foo: 2}]) 会返回 [{foo: 1}]。

如果你的数组只包含基本类型，并且不需要区分类型，这可以放心使用这个方法。

结合对象和数组的线性搜索

我们可以结合对象和数组的线性搜索方法来解决上述问题。

function removeDuplicates(arr) {
  const prims = { boolean: {}, number: {}, string: {} };
  const objs = [];
  return arr.filter((item) => {
    const type = typeof item;
    if (type in prims) {
      if (prims[type].hasOwnProperty(item)) {
        return false;
      } else {
        prims[type][item] = true;
        return true;
      }
    } else {
      if (objs.indexOf(item) >= 0) {
        return false;
      } else {
        objs.push(item);
        return true;
      }
    }
  });
}
const myArray = [1, 2, 3, 2, 4, 1, 5, { foo: 1 }, { foo: 2 }];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5, { foo: 1 }, { foo: 2 }]

主要优点

• 分类存储：通过将基本类型和对象类型分别存储，减少了不同类型之间的冲突，逻辑清晰。
• 高效处理基本类型：使用对象存储基本类型，查找和存储操作的时间复杂度为 O(1)，效率较高。

存在的问题

• 1、对象类型处理问题：
• 引用比较：代码使用 indexOf 方法判断对象是否存在于数组中，这实际上是比较对象的引用而不是内容。即使两个对象内容相同，但引用不同，indexOf 也会返回 -1，导致内容相同但引用不同的对象被认为是不同的。例如，{ foo: 1 } 和另一个 { foo: 1 } 会被当作两个不同的对象。
• 性能问题：对于大量对象类型的元素，由于 indexOf 方法需要遍历整个数组，时间复杂度为 O(n)，性能较差。
• 2、不能深度比较：对于嵌套对象或数组，该方法无法进行深度比较。例如，{ foo: [1, 2] } 和 { foo: [1, 2] } 这样的对象，内容相同但引用不同，会被认为是不同的对象。

最终方案：编写深度比较函数

编写深度比较函数 isDeepDataStructureEquality，用来比较两个对象的内容是否相同。

function isDeepDataStructureEquality(a, b) {
    let isEqual = Object.is(a, b);

    if (!isEqual) {
      if (Array.isArray(a) && Array.isArray(b)) {

        isEqual = (a.length === b.length) && a.every(
          (item, idx) => isDeepDataStructureEquality(item, b[idx])
        );
      } else if (
        a && b
        && (typeof a === 'object')
        && (typeof b === 'object')
      ) {
        const aKeys = Object.keys(a);
        const bKeys = Object.keys(b);

        isEqual = (aKeys.length === bKeys.length) && aKeys.every(
          (key, idx) => isDeepDataStructureEquality(a[key], b[key])
        );
      }
    }
    return isEqual;
  }

function removeDuplicates(arr) {
  const primitives = { boolean: {}, number: {}, string: {} };
  const objs = [];
  return arr.filter(item => {
    const type = typeof item;
    if (type in primitives) {
      if (primitives[type].hasOwnProperty(item)) {
        return false;
      } else {
        primitives[type][item] = true;
        return true;
      }
    } else {
      if (objs.some(obj => isDeepDataStructureEquality(obj, item))) {
        return false;
      } else {
        objs.push(item);
        return true;
      }
    }
  });
}

方法三：排序去重

另一种去重方法是先排序数组，然后去除连续重复的元素。

function removeDuplicates(arr) {
  return arr.sort().filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
}
const myArray = [1, 2, 3, 2, 4, 1, 5];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

这个方法首先使用 sort 方法对数组进行排序，然后使用 filter 方法去除连续的重复元素。虽然对已排序的数组很有效，但无法处理对象数组。

方法四：使用 Set 处理对象

对于包含对象的数组，我们可以利用 Set 数据结构来高效去重。因为 Set 只存储唯一值，我们可以将数组转换为 Set，然后再转换回数组。

function removeDuplicates(arr) {
  return [...new Set(arr)];
}
const myArray = [1, 2, 3, 2, 4, 1, 5, { foo: 1 }, { foo: 2 }];
const uniqueArray = removeDuplicates(myArray);
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5, { foo: 1 }, { foo: 2 }]

这个方法通过 new Set(arr) 创建一个新的集合，然后使用扩展运算符 ... 将集合展开为数组，去重过程简单且高效。

• 优点
• 简洁：代码非常简洁，只需一行代码即可实现数组去重。
• 高效：Set 数据结构在插入元素时自动去重，性能较好，时间复杂度为 O(n)。
• 存在的问题
• 对象引用问题：Set 判断元素是否相等时，使用的是同一对象引用。例如，两个内容相同但引用不同的对象 { foo: 1 } 和 { foo: 1 } 会被视为不同的元素。

总结

在实际开发中，选择合适的数组去重方法非常重要。如果数组主要包含基本类型，使用 Set 是一种简洁高效的选择。如果数组中包含复杂结构的对象，可以结合深度比较函数来确保去重的准确性。

无论你选择哪种方法，都要根据具体的应用场景和数据特点来决定。希望这些方法能帮助你在实际开发中更优雅地解决数组去重问题。如果你有其他更好的方法或建议，欢迎在评论区分享哦！

如果你喜欢这篇文章，请点赞并关注，更多前端技巧和小妙招等着你哦！