網頁設計和開發的過程中，CSS（層疊樣式表）文件扮演著至關重要的角色，它們負責為網頁賦予樣式和美感。然而，有時在整理項目文件或進行清理時，我們可能會考慮是否可以刪除某些CSS文件。那么，CSS文件可以刪除嗎？如果不小心刪除了CSS文件，我們又該如何找回呢？本文將探討這些問題，并提供相應的解決方案。

CSS是什么文件？

CSS是層疊樣式表（Cascading Style Sheets）的縮寫，是一種用于定義網頁樣式和布局的標記語言。CSS是一種簡單的樣式表語言，用于描述HTML或XML文檔的外觀和格式。通過CSS文件，可以設置網頁的字體、顏色、邊距、邊框、背景等樣式，使網頁呈現出不同的視覺效果。CSS文件通常以.css作為文件擴展名。

CSS文件可以刪除嗎？

CSS文件本身并不是網站運行所必需的，因為HTML文件本身也包含內聯樣式和基本的結構樣式。但是，為了保持網站的外觀和用戶體驗的一致性，我們通常會將樣式定義在單獨的CSS文件中。因此，從技術上講，CSS文件可以被刪除，但這會導致網頁失去樣式，變得難以閱讀和使用。

CSS文件刪除了怎么找回來？

怎么找回刪除的CSS文件？這確實是一個令人頭疼的問題。但別擔心，只要采取正確的措施，還是有可能找回的。

首先，要立刻停止在CSS文件所在磁盤中進行任何新的操作，以防覆蓋被刪除的文件。接下來，可以嘗試以下幾種方法來找回CSS文件：

方案1、備份文件恢復

首先，檢查您是否有備份。備份是防止數據丟失的最有效方法。如果您定期備份了網站文件，那么從備份中恢復CSS文件是最直接和可靠的方式。

方案2、使用版本控制

如果你使用了版本控制工具（如Git），你可以輕松查看歷史記錄，找到被刪除的文件，并將其恢復到最新版本。使用版本控制可以方便地追蹤文件變更歷史，是防止誤刪的重要措施。

方案3、從回收站中還原

如果CSS文件是在本地計算機上被刪除的，檢查回收站，看看是否有該文件。要檢查您的回收站是否包含被刪除的CSS文件，您可以按照以下步驟進行操作：

1）在計算機桌面上找到回收站圖標，并雙擊打開它。

2）在回收站窗口中，您可以查看所有最近刪除的文件和文件夾。

3）如果找到了CSS文件右鍵單擊，選擇“還原”即可將其恢復到原來的位置。

方案4、使用數據恢復軟件

如果回收站也被清空，CSS文件刪除了還能恢復嗎？您可以嘗試使用數據恢復軟件。軟件可以掃描硬盤，嘗試找回被刪除的文件。但請注意，任何數據恢復軟件都無法百分百恢復，因此建議優先使用支持免費掃描和預覽的軟件進行預判。

下面以云騎士數據恢復軟件為例進行操作：

1）在官網下載軟件并按提示安裝在電腦上，啟動后選擇相應的恢復模式，如場景模式中的“誤刪除文件”。

2）接著在界面右側選擇CSS文件原本所在磁盤，勾選后點擊右下角的“開始掃描”按鈕，等待軟件自動掃描結束。

3）掃描完成后，如果有太多的結果，建議在文檔文件類型下查找CSS格式的文件，或者搜索文件名等方式縮小查找范圍，然后預覽找到的文件。

4）最后將預覽無誤的CSS文件（能看到文字）勾選上，點擊“立即恢復”按鈕，將文件另存到其他磁盤中進行查看即可。

方案5、尋求專業幫助

如果以上方法都無法找回CSS文件，如您的電腦出現物理性故障、無法開機或者藍屏等情況，建議您尋求線下專業人員的幫助來恢復丟失的文件。

CSS文件相關問答

CSS文件覆蓋之后能恢復嗎？

一旦文件被覆蓋，通常情況下是無法完全恢復原始文件的。當文件被覆蓋時，原始數據會被新數據所替代，導致原始文件的內容無法被完整恢復。雖然數據恢復軟件有時可能能夠部分恢復被覆蓋的文件的一些片段或碎片，但是恢復的成功率通常較低。

總結：

CSS文件雖然可以被刪除，但刪除它們通常會導致網站失去樣式和美觀性，影響用戶體驗。因此，在刪除任何文件之前，都應該仔細考慮其影響。如果不幸刪除了CSS文件，可以通過上述介紹的方法嘗試找回。但最好的做法始終是預防，如果所有方法都無法找回文件，重新編寫樣式可能是最后的解決方案。

往期推薦：

js文件刪除了怎么恢復？找回方法與預防措施

「2024指南」tf卡格式化了數據怎么恢復？

chkdsk修復會造成文件丟失嗎？chkdsk數據丟失還能恢復嗎

日常編程中，我們經常會遇到數組去重的問題。今天，我們就來聊聊如何用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(n2)。

方法二：使用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(n2)，因為 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 是一種簡潔高效的選擇。如果數組中包含復雜結構的對象，可以結合深度比較函數來確保去重的準確性。

無論你選擇哪種方法，都要根據具體的應用場景和數據特點來決定。希望這些方法能幫助你在實際開發中更優雅地解決數組去重問題。如果你有其他更好的方法或建議，歡迎在評論區分享哦！

如果你喜歡這篇文章，請點贊并關注，更多前端技巧和小妙招等著你哦！

面文章，實現了通過表單完成數據的錄入，并寫入數據庫。接下來實現數據的修改和刪除。

首先找到user_manager.html文件，增加修改和刪除的按鈕。

找到顯示數據的表格<table>標簽，在表頭區域增加一列<th>操作</th>，然后在顯示數據的for循環中增加一個<td></td>標簽,在標簽內增加兩個連接<a>標簽，href先設置為空，各增加一個class樣式。如圖所示：

刷新user_manager.html頁面，如下圖。現在按鈕已經添加到前端頁面。

接下來，完善刪除功能。

先在views.py中建立一個刪除的方法，如下。方法傳入兩個參數，一個request，一個需要刪除行的id，使用User類的filter功能在數據庫中查找數據，使用delete()方法刪除數據，最后返回user_manager頁面。

def user_delete(request,user_id):
    User.objects.filter(id=user_id).delete()
    return redirect("/user_manager/")

接下來增加路由，以在前端調用該方法刪除數據。打開urls.py文件，新增加一個刪除數據的路由。

在前端user_manager.html頁面中，增加刪除的href如下：

試驗一下刪除功能，打開user_manager.html頁面，找到第一條數據，

點擊刪除按鈕，第一條數據已被刪除。

下篇筆記，將記錄如何實現修改數據的功能。