Chrome-Erweiterung erstellen | Original, von KI übersetzt
Hast du dich jemals gefragt, wie es wäre, wenn du zu viele Browser-Tabs geöffnet hast und ein Tool hättest, das sie automatisch verwaltet? In diesem Blogbeitrag werden wir die Erstellung einer Chrome-Erweiterung namens “Tabs Killer” durchgehen, die automatisch die ältesten Tabs schließt, wenn die Anzahl der Tabs eine benutzerdefinierte Grenze überschreitet. Ich werde den Code aufschlüsseln, erklären, wie er funktioniert, und Einblicke geben, um dir zu helfen, deine eigene Chrome-Erweiterung zu erstellen.
Bis zum Ende dieses Beitrags wirst du die Struktur einer Chrome-Erweiterung verstehen, wie man mit der Chrome-API arbeitet und wie man eine Popup-Oberfläche mit Einstellungen erstellt.
Was macht “Tabs Killer”?
“Tabs Killer” ist eine Chrome-Erweiterung, die:
- Die Anzahl der geöffneten Tabs überwacht.
- Benutzern ermöglicht, eine maximale Tab-Grenze festzulegen.
- Automatisch die ältesten Tabs schließt, wenn die Grenze überschritten wird.
- Ein Whitelist-Feature bietet, um bestimmte Tabs (z. B. basierend auf URL-Mustern) vor dem Schließen zu schützen.
Die Erweiterung enthält eine Popup-Oberfläche zur Konfiguration der Einstellungen und ein Hintergrundskript zur Verwaltung der Tabs.
Projektstruktur
Hier ist die Dateistruktur der “Tabs Killer”-Erweiterung:
tabs-killer/
├── manifest.json # Erweiterungs-Konfiguration
├── popup.html # Popup-Benutzeroberfläche
├── popup.js # Popup-Logik
├── background.html # Hintergrundseite
├── app.build.js # Hauptanwendungslogik (angenommen)
├── js/
│ ├── lib/ # Externe Bibliotheken (jQuery, Underscore, Bootstrap, RequireJS)
│ ├── tabmanager.js # Tab-Verwaltungslogik (angenommen)
│ └── settings.js # Einstellungsverwaltung (angenommen)
├── css/
│ └── popup.css # Popup-Stile
└── img/
├── icon16.png # 16x16 Icon
├── icon48.png # 48x48 Icon
└── icon128.png # 128x128 Icon
Schritt 1: Die Manifest-Datei (manifest.json
)
Die manifest.json
-Datei ist das Herzstück jeder Chrome-Erweiterung. Sie definiert Metadaten, Berechtigungen und Schlüsselkomponenten.
{
"manifest_version": 2,
"name": "Tabs Killer",
"description": "Schließt automatisch die ältesten Tabs, wenn zu viele Tabs geöffnet sind.",
"version": "1.0",
"browser_action": {
"default_icon": "img/icon128.png",
"default_popup": "popup.html"
},
"icons": {
"128": "img/icon128.png",
"48": "img/icon48.png",
"16": "img/icon16.png"
},
"background": {
"page": "background.html"
},
"permissions": [
"tabs",
"storage"
],
"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self'"
}
Erklärung:
manifest_version
: Muss2
sein (Chrome hat Version 1 veraltet).name
,description
,version
: Grundlegende Metadaten.browser_action
: Definiert das Symbol der Erweiterung und das Popup (popup.html
).icons
: Symbole in verschiedenen Größen (im Chrome Web Store und in der Symbolleiste verwendet).background
: Gibt eine Hintergrundseite (background.html
) an, die dauerhaft läuft.permissions
: Fordert Zugriff auf dietabs
-API (zur Verwaltung der Tabs) und diestorage
-API (zum Speichern der Einstellungen) an.content_security_policy
: Erlaubtunsafe-eval
für Bibliotheken wie RequireJS (in der Produktion vorsichtig verwenden).
Schritt 2: Die Popup-Oberfläche (popup.html
)
Das Popup erscheint, wenn der Benutzer auf das Symbol der Erweiterung klickt. Es verwendet Bootstrap für die Stilgestaltung und enthält eine Registerkarten-Oberfläche mit einem “Optionen”-Bereich.
<!doctype html>
<html>
<head>
<title>Popup der Tabs Killer-Erweiterung</title>
<link rel="stylesheet" href="js/lib/bootstrap/css/bootstrap.css" type="text/css"/>
<link rel="stylesheet" href="css/popup.css"/>
<script src="js/lib/jquery.min.js"></script>
<script src="js/lib/underscore.js"></script>
<script src="js/lib/bootstrap/js/bootstrap.min.js"></script>
<script src="js/lib/bootstrap/js/bootstrap-tab.js"></script>
<script src="js/lib/require.js"></script>
<script src="app.build.js"></script>
<script src="popup.js"></script>
</head>
<body>
<ul class="nav nav-tabs">
<li><a href="#tabOptions" target="#tabOptions" data-toggle="tab">Optionen</a></li>
</ul>
<div class="tab-content">
<div class="tab-pane active" id="tabOptions">
<form class="well">
<fieldset>
<legend>Einstellungen</legend>
<p>
<label for="maxTabs">Maximale Anzahl der Tabs</label>
<input type="text" id="maxTabs" class="span1" name="maxTabs"> Tabs
</p>
</fieldset>
<div id="status" class="alert alert-success invisible"></div>
<fieldset>
<legend>Auto-Lock</legend>
<label for="white-list-input">Tab mit URL, die den String enthält:</label>
<input type="text" id="white-list-input"/>
<button class="btn-mini add-on" disabled id="white-list-add">Hinzufügen</button>
<table class="table table-bordered table-striped" id="white-list">
<thead>
<tr>
<th>URL-Muster</th>
<th></th>
</tr>
</thead>
<tbody></tbody>
</table>
</fieldset>
</form>
</div>
</div>
<script type="text/html" id="url-item-template">
<tr>
<td><%=url%></td>
<td><a class="deleteLink" href="#">Entfernen</a></td>
</tr>
</script>
</body>
</html>
Erklärung:
- Bibliotheken: Verwendet jQuery, Underscore, Bootstrap und RequireJS für Funktionalität und Stilgestaltung.
- Benutzeroberflächen-Elemente:
- Ein Text-Eingabefeld (
#maxTabs
) zum Festlegen der maximalen Anzahl von Tabs. - Ein Whitelist-Eingabefeld (
#white-list-input
) und eine “Hinzufügen”-Schaltfläche (#white-list-add
), um bestimmte URLs zu schützen. - Eine Tabelle (
#white-list
), um Whitelist-Muster mit einem “Entfernen”-Link anzuzeigen. - Eine Statusmeldung (
#status
), um Rückmeldungen zum Speichern anzuzeigen.
- Ein Text-Eingabefeld (
- Vorlage: Eine Underscore.js-Vorlage (
#url-item-template
), die Tabellenzeilen dynamisch generiert.
Schritt 3: Popup-Logik (popup.js
)
Dieses Skript verarbeitet die Interaktivität des Popups, wie das Speichern von Einstellungen und das Verwalten der Whitelist.
require([], function () {
var GlobalObject = chrome.extension.getBackgroundPage().GlobalObject;
Popup = {};
Popup.optionsTab = {};
Popup.optionsTab.init = function (context) {
function onBlurInput() {
var key = this.id;
Popup.optionsTab.saveOption(key, $(this).val());
}
$('#maxTabs').keyup(_.debounce(onBlurInput, 200));
Popup.optionsTab.loadOptions();
};
Popup.optionsTab.loadOptions = function () {
$('#maxTabs').val(GlobalObject.settings.get('maxTabs'));
var whiteList = GlobalObject.settings.get('whiteList');
Popup.optionsTab.buildWhiteListTable(whiteList);
var $whiteListInput = $('#white-list-input');
var $whiteListAdd = $('#white-list-add');
var isValid = function (pattern) {
return /\S/.test(pattern);
};
$whiteListInput.on('input', function () {
if (isValid($whiteListInput.val())) {
$whiteListAdd.removeAttr('disabled');
} else {
$whiteListAdd.attr('disabled', 'disabled');
}
});
$whiteListAdd.click(function () {
if (!isValid($whiteListInput.val())) return;
whiteList.push($whiteListInput.val());
$whiteListInput.val('').trigger('input').focus();
Popup.optionsTab.saveOption('whiteList', whiteList);
Popup.optionsTab.buildWhiteListTable(whiteList);
});
};
Popup.optionsTab.saveOption = function (key, value, hideStatus) {
if (!hideStatus) $('#status').html('');
GlobalObject.settings.set(key, value);
if (!hideStatus) {
$('#status').removeClass('invisible').css('opacity', '100')
.html('Speichern...').delay(50).animate({opacity: 0});
}
};
Popup.optionsTab.buildWhiteListTable = function (whiteList) {
var urlItemTemplate = _.template($("#url-item-template").html());
var $wlTable = $('table#white-list tbody');
$wlTable.html('');
for (var i = 0; i < whiteList.length; i++) {
var $tr = $(urlItemTemplate({url: whiteList[i]}));
var $deleteLink = $tr.find('a.deleteLink').parent();
$deleteLink.click(function () {
whiteList.splice(whiteList.indexOf($(this).data('pattern')), 1);
Popup.optionsTab.saveOption('whiteList', whiteList, true);
Popup.optionsTab.buildWhiteListTable(whiteList);
}).data('pattern', whiteList[i]);
$wlTable.append($tr);
}
};
$(document).ready(function () {
$('a[data-toggle="tab"]').on('show', function (e) {
var tabId = e.target.hash;
if (tabId === '#tabOptions') {
Popup.optionsTab.init($('div#tabOptions'));
}
});
$('a[href="#tabOptions"]').click();
});
});
Erklärung:
- Initialisierung: Verbindet sich mit dem Hintergrundskript
GlobalObject
für Einstellungen und Tab-Verwaltung. init
: Richtet Ereignis-Listener ein, wie z. B. verzögerte Eingabe für#maxTabs
.loadOptions
: Lädt gespeicherte Einstellungen (maximale Tabs und Whitelist) und füllt die Benutzeroberfläche.saveOption
: Speichert Einstellungen inGlobalObject.settings
und zeigt eine “Speichern…“-Animation an.buildWhiteListTable
: Erstellt dynamisch die Whitelist-Tabelle mit Löschfunktion.- Ereignis-Listener: Verarbeitet Eingabevalidierung, Hinzufügen von Whitelist-Einträgen und Tab-Wechsel.
Schritt 4: Hintergrundlogik (background.html
und angenommene Skripte)
Die Hintergrundseite (background.html
) läuft dauerhaft und lädt die Kernlogik.
// background.js (angenommen, basierend auf bereitgestelltem Snippet)
GlobalObject = {};
require(['tabmanager', 'settings'], function (tabmanager, settings) {
var startup = function () {
GlobalObject.settings = settings;
GlobalObject.tabmanager = tabmanager;
settings.init();
tabmanager.init();
};
startup();
});
Annahmen:
settings.js
: Verwalten des Speichers (z. B.chrome.storage
) für Einstellungen wiemaxTabs
undwhiteList
.tabmanager.js
: Verwenden dertabs
-API, um Tabs basierend auf dermaxTabs
-Grenze undwhiteList
zu überwachen und zu schließen.
Beispiel tabmanager.js
(hypothetisch):
var tabmanager = {
init: function () {
chrome.tabs.onCreated.addListener(this.checkTabCount);
},
checkTabCount: function () {
chrome.tabs.query({}, function (tabs) {
var maxTabs = GlobalObject.settings.get('maxTabs') || 10;
var whiteList = GlobalObject.settings.get('whiteList') || [];
if (tabs.length > maxTabs) {
var tabsToRemove = tabs.filter(tab => !whiteList.some(pattern => tab.url.includes(pattern)));
chrome.tabs.remove(tabsToRemove[0].id); // Entferne ältesten Tab
}
});
}
};
So testest du die Erweiterung
- Öffne Chrome und gehe zu
chrome://extensions/
. - Aktiviere den “Entwicklermodus” (oben rechts).
- Klicke auf “Unpacked load” und wähle den
tabs-killer
-Ordner aus. - Klicke auf das Symbol der Erweiterung, um das Popup zu öffnen und die Einstellungen zu testen.
Tipps zum Schreiben deiner eigenen Chrome-Erweiterung
- Klein anfangen: Beginne mit einem einfachen Manifest und einem Popup oder Hintergrundskript.
- Chrome-APIs verwenden: Nutze
chrome.tabs
,chrome.storage
und andere nach Bedarf. - Debugging: Verwende
console.log
und Chrome’s DevTools (Rechtsklick auf Popup > Inspectieren). - Sicherheit: Vermeide
unsafe-eval
in der Produktion; verwende strengere Content Security Policies. - UI-Bibliotheken: Bootstrap und jQuery erleichtern die UI-Entwicklung, halte die Erweiterung aber leichtgewichtig.
Fazit
“Tabs Killer” zeigt, wie man eine Popup-Oberfläche, Hintergrundlogik und Chrome-APIs kombiniert, um eine funktionale Erweiterung zu erstellen. Mit dieser Grundlage kannst du sie weiter anpassen – Benachrichtigungen hinzufügen, die Tab-Schließlogik verfeinern oder die Benutzeroberfläche verbessern.
Fühl dich frei, mit dem Code zu experimentieren und deine eigenen Chrome-Erweiterungsideen zu teilen! Viel Spaß beim Codieren!