Hur skapar du en inloggningssida med användarnamn och lösenordsfält?
Att skapa en inloggningssida involverar både front-end (HTML, CSS, JavaScript) för användargränssnittet och back-end (serversidan och databas) för autentisering och datahantering. Här är en uppdelning av hur du skapar en inloggningssida som täcker både front-end och ett förenklat exempel på back-end-metoden.
1. Front -End (HTML Structure - `inloggning.html`)
`` `html
Logga in
inloggning
`` `
Nyckelpunkter:
* ``: Förklarar dokumenttypen som HTML5.
* ``: Anger teckenkodningen för dokumentet.
* ``: Konfigurerar visningsporten för lyhörd design.
* ``: Ställer in titeln som visas på fliken Webbläsare.
* ` `: Länkar till din CSS -fil för styling.
* `
`: En containerdiv för att hålla inloggningsformuläret och dess element, underlätta styling.
* `
inloggning
`: En rubrik för inloggningsformuläret.
* ` Kärnan i formuläret:
* `id =" Loginform "`:ger en unik identifierare för formen, så att du kan manipulera den med JavaScript.
* `action ="/login "`: avgörande viktigt! Detta anger URL:n på din server som hanterar inloggningsbegäran när formuläret skickas in. Byt ut `/inloggning" med den faktiska sökvägen till din serversidan inloggningsändpunkt.
* `Method =" Post "`:indikerar att formulärdata kommer att skickas till servern med HTTP POST -metoden, som i allmänhet är säkrare för känslig data som lösenord.
* `
`: Behållare för etiketter och inmatningsfält, som hjälper till styling och organisation.
* `` och ``:
* `Etikett`:tillhandahåller en textetikett för inmatningsfältet. Attributet "för" bör matcha "ID" i det inmatningsfält som det är associerat med.
* `Input Type =" Text "`:Skapar ett textinmatningsfält för användarnamnet. `name =" användarnamn "` är viktigt-koden för serversidan kommer att använda detta namn för att komma åt det värde som anges av användaren. "Obligatoriskt" gör fältet obligatoriskt.
* ``: Skapar ett inmatningsfält för lösenord. "Type =" Lösenordet "" -attributet maskerar ingången som användartyper. `name =" lösenord "" används av koden för serversidan. "Obligatoriskt" gör fältet obligatoriskt.
* ` Skicka -knappen som utlöser formuläret.
* `
`: En platshållare för att visa felmeddelanden från servern, om autentisering misslyckas.
* ` `: Länkar till din JavaScript-fil för validering av klientsidan eller andra interaktioner.
2. Front -end (CSS styling - `style.css`)
`` `CSS
kropp {
font-familj:sans-serif;
Bakgrundsfärg:#F4F4F4;
Display:flex;
Justera-Content:Center;
Just-artiklar:center;
min-höjd:100vh;
}
.login-container {
Bakgrundsfärg:#fff;
Polstring:20px;
Border-Radius:8px;
Box-Shadow:0 0 10px RGBA (0, 0, 0, 0.1);
bredd:300 px;
}
.form-grupp {
marginalbotten:15px;
}
etikett {
Display:block;
marginalbotten:5px;
}
input [type ="text"],
input [type ="lösenord"] {
bredd:100%;
POLDING:8px;
Border:1px Solid #CCC;
Border-Radius:4px;
Box-storlek:Border-box; / * Inkludera stoppning och gräns i elementets totala bredd och höjd */
}
knapp {
Bakgrundsfärg:#4CAF50;
Färg:vit;
POLDING:10px 15px;
Gränsen:ingen;
Border-Radius:4px;
markör:pekare;
bredd:100%;
}
Knapp:Hover {
Bakgrundsfärg:#3E8E41;
}
.Error-Message {
Färg:röd;
marginal-top:10px;
}
`` `
Denna CSS tillhandahåller grundläggande styling för att centrera inloggningsformuläret, utforma inmatningsfält och knapp och ge en visuell indikator för felmeddelanden.
3. Front -End (JavaScript - `Script.js` - Valfri validering av klientsidan)
ErrorMessAgediv.textContent =''; // Rensa tidigare fel
if (! Användarnamn ||! Lösenord) {
ErrorMessAgediv.TextContent ='Ange både användarnamn och lösenord.';
Event.PreventDefault (); // Förhindra inlämning av formulär
återvända;
}
// Du kan lägga till mer komplex validering av klientsidan här, som lösenordsstyrka kontroller.
});
`` `
Detta JavaScript lägger till en valideringskontroll på klientsidan att både användarnamn och lösenord har fyllts innan du skickar formuläret till servern. Det är valfritt men förbättrar användarupplevelsen genom att ge omedelbar feedback.
4. Back -end (node.js with express - exempel)
Detta är ett grundläggande exempel med Node.js och Express -ramverket. Du måste installera dessa:
`` `bash
npm installera express body-parser bcrypt
`` `
* `Express`: En webbapplikationsram för Node.js.
* `Body-Parser`: Middleware för att analysera begäran.
* `bcrypt`: Bibliotek för hashing -lösenord säkert. (Viktigt för säkerhet!)
`` `JavaScript
const express =kräva ('express');
const BodyParser =kräva ('body-parser');
const bcrypt =kräva ('bcrypt');
const app =express ();
const port =3000;
// In-Memory användardatabas (ersätt med en riktig databas som MongoDB eller PostgreSQL)
const -användare =[]; // array av användarobjekt {användarnamn, lösenordshash}
console.log (`server lyssnar på http:// localhost:$ {port}`);
});
`` `
Förklaring av back-end-koden:
1. Import: Importerar nödvändiga moduler:`Express ',` body-parser` och `bcrypt`.
2. Initialisering: Skapar en Express Application -instans (`App ') och ställer in porten.
3. Middleware:
* `BODYPARSER.URLENCODED ({Extended:False})`:Parses URL-kodade förfrågningsorgan (data skickade från HTML-formulär). `Extended:False 'använder det inbyggda QueryString-biblioteket, medan` Extended:True' använder "QS" -biblioteket, vilket möjliggör mer komplexa objektstrukturer.
* `bodyparser.json ()`:parses json begär organ.
* `Express.Static ('Public')`:serverar statiska filer (HTML, CSS, JavaScript) från katalogen 'Public'. Det är här du satte din "inloggning.html", "style.css" och "script.js".
4. Rutt för att servera inloggningssidan (`/`):
* `app.get ('/', ...)`:Definierar en rutt som hanterar får förfrågningar till rotvägen (`/`).
* `res.sendfile (__ dirname + '/public/login.html')`:skickar filen 'Logga in.html' till klienten. `__Dirname` är den aktuella katalogen för skriptet, vilket säkerställer att filvägen är korrekt.
5. Rutt för inlämning av inloggning (`/inloggning '):
* `app.post ('/inloggning', ...)`:Definierar en rutt som hanterar postförfrågningar till `/inloggning '. Det är här inloggningsformulärdata skickas.
* `REQ.BODY ':Innehåller de data som skickas från formuläret. Tack vare `Body-Parser 'kan du komma åt användarnamnet och lösenordet med` req.body.username` och `req.body.password'.
* `user.find (u => u.username ===Användarnamn)`:Söker `användare 'array efter en användare med det matchande användarnamnet. (I en riktig applikation skulle du fråga din databas.)
* Lösenordshashing med `bcrypt`:
* `bcrypt.compare (lösenord, user.passwordhash)`:Detta är den avgörande delen för säkerhet. Den jämför det klartext som lösenord som anges av användaren med den lagrade * hash * i lösenordet. `Bcrypt` hanterar saltningsprocessen automatiskt. Detta är mycket säkrare än att lagra lösenord i klartext.
* autentiseringslogik:
* Om en användare hittas och lösenordet matchar, ställer du vanligtvis en sessionskaka för att autentisera användaren och omdirigera dem till ett inloggat område. I det här exemplet skickar det bara en "inloggning framgångsrik!" meddelande.
* Om användaren inte hittas eller lösenordet inte matchar skickar det ett felrespons (`401 obehörig). Front-end JavaScript kan sedan visa detta felmeddelande till användaren.
6. Rutt för registrering
* Lade till en registerväg för att tillåta att nya användare läggs till i systemet
* Lösenord lagras inte men hashas för att säkerställa säkerhet
7. Starta servern:
* `App.Listen (port, ...)`:Starta Express -servern på den angivna porten.
Viktiga överväganden och bästa praxis för säkerhet:
* databas: Byt ut i minnet "användare" -uppsättning med en riktig databas (t.ex. MongoDB, PostgreSQL, MySQL). Använd ett databasbibliotek (som Mongoose för MongoDB eller följare för PostgreSQL/MySQL) för att interagera med databasen.
* Lösenordshashing: * Lagra aldrig lösenord i klartext. Använd alltid en stark lösenordshash -algoritm som `bcrypt '(som visas i exemplet). `Bcrypt` inkluderar saltning, vilket gör det mycket svårare för angripare att knäcka lösenord även om de får databasen. Använd `bcrypt.hash ()` till hash -lösenord när användare registrerar sig, och `bcrypt.compare ()` för att jämföra det angivna lösenordet med den lagrade hashen under inloggning.
* Ingångsvalidering: Validera användarinmatning på både klientsidan (för användarupplevelse) och serversidan (för säkerhet). Sanit in ingången för att förhindra injektionsattacker (t.ex. SQL -injektion, XSS).
* sessionhantering: Använd sessioner för att upprätthålla användarinloggningstillstånd. Efter en framgångsrik inloggning, lagra ett session -ID i en cookie i klientens webbläsare. Vid efterföljande förfrågningar kan servern använda session -ID för att identifiera användaren utan att kräva att de loggar in igen. Bibliotek som "Express-session" kan hjälpa till att hantera sessioner.
* https: Använd alltid HTTPS (SSL/TLS) för att kryptera kommunikation mellan klienten och servern. Detta förhindrar avlyssning och man-in-the-middle-attacker. Få ett SSL -certifikat från en certifikatmyndighet (t.ex. låt oss kryptera).
* Felhantering: Implementera korrekt felhantering för att förhindra att känslig information exponeras i felmeddelanden. Logga fel säkert.
* CSRF -skydd: Skydda mot CSRF (CSRF) attacker med CSRF-tokens.
* Ratsbegränsning: Implementera hastighetsbegränsning för att förhindra brute-force-attacker på inloggningsändpunkten.
Hur man kör exemplet:
1. Skapa projektkatalog: Skapa en katalog för ditt projekt (t.ex. `inloggning-app ').
2. Skapa filer: Skapa följande filer i projektkatalogen:
* `Logga in.html` (Kopiera HTML -koden)
* `style.css` (kopiera CSS -koden)
* `Script.js` (Kopiera JavaScript -koden)
* `server.js` (eller` app.js`, eller vad du vill namnge din node.js serverfil - kopiera node.js -koden)
* Skapa en "allmän" mapp och lägg `inloggning.html`,` style.css` och `script.js` inuti.
3. Installera beroenden: Öppna en terminal i projektkatalogen och kör:
`` `bash
npm installera express body-parser bcrypt
`` `
4. Kör servern: I terminalen, kör:
`` `bash
node server.js
`` `
5. Öppet i webbläsaren: Öppna din webbläsare och gå till `http:// localhost:3000". Du bör se inloggningssidan.
Kom ihåg att detta är ett grundläggande exempel. För en verklig applikation måste du implementera korrekt databasintegration, sessionhantering och säkerhetsåtgärder.