PHP filter_var och filter_input

Inspiration ur boken ”PHP Object Oriented Solutions” av David Powers

Det finns sju funktioner som används för att validering av inmatning, men endast fyra som faktiskt gör något filtrering eller validering. Du styr vad som accepteras eller förkastas genom att en rad PHP konstanter som argument till funktionen. Det finns 50 konstanter förknippade med filterfunktioner, vilket gör dem mycket mångsidig, men samtidigt komplexa.

 

 

Filter funktioner

  • filter_has_var() Kontrollerar om en variabel av en viss inmatnings typ existerar
  • filter_id () Returnerar ID-nummer för ett specifierat filter
  • filter_input () Ta inmatning utanför skriptet och filtrera den
  • filter_input_array () Ta flera inmatningskällor utanför skriptet och filtrerar dem
  • filter_list () Returnerar en array med alla filter som stöds
  • filter_var_array () Ta flera variabler och filtrera dem
  • filter_var () Ta en variabel och filtrera den

Tre funktioner – filter_has_var(), filter_input(), och filter_input_array() – är utformad för att fungera med superglobal arrayer, till exempel $_POST och $_GET. Men istället för att använda superglobal variabeln, måste man hänvisa till arrayen med motsvarande filterkonstant.

 

Konstanter » superglobal

Dessa filter funktioner är utformad för att fungera med superglobal arrayer, till exempel $_POST och $_GET. Men istället för att använda superglobal variabler, måste du hänvisa till den med motsvarande filterkonstant.

De konstanter och deras motsvarigheter listas här nedanför:

  • INPUT_COOKIE     $_COOKIE variabler
  • INPUT_ENV           $_ENV variabler
  • INPUT_GET            $_GET variabler
  • INPUT_POST         $_POST variabler
  • INPUT_REQUEST  $_REQUEST variabler
  • INPUT_SERVER     $_SERVER variabler
  • INPUT_SESSION   $_SESSION variable

 

filter_input och filter_var

Två av filter-funktionerna används för validering av enskilda variabler: filter_input() och filter_var(). Skillnaden mellan dem är att filter_input() hanterar en variabel som har kommit från ett av superglobal array, till exempel $_POST; filter_var() hanterar en variabel som har kommit från någon annan källa, som till exempel en databas eller en include-fil.

 

Filter argument

filter_input funktionen tar fyra argument, nämligen:

  • $source: Detta indikerar superglobal array som innehåller variabeln som du vill filtrera. Du måste använda en av de konstanter som anges i tabell 4-2, till exempel, INPUT_POST.
  • $variableName: Detta är namnet på variabeln som du vill filtrera.
  • $filter: Det här är filtret som du vill använda. Du måste ange en av filterkonstanter . Alternativt kan du använda filter_id () med namnet på filtret. Om det här argumentet utelämnas, använder PHP standardfiltret.
  • $alternativ: Detta är en valfri array som innehåller eventuella tillval eller flaggor som du vill använda.

filter_var() tar inte den första av dessa argument ($source), men de övriga tre är desamma som för både filter_input(). och filter_var().
Eftersom båda funktionerna är väldigt lika varandra ska jag gå igenom båda under den här guiden, men låt oss börja med att experimentera med filter_var() genom att hårdkoda in vissa värden.

 

2 flaggor för alla filter

  • Flagga FILTER_REQUIRE_ARRAY

Detta avvisar alla värden som inte är en array. När denna flagga är satt innebär att filtret tillämpas på samtliga delar av arrayen. Det fungerar även på flerdimensionella arrayer, tillämpar filtret rekursivt till varje nivå.

  • Flagga FILTER_REQUIRE_SCALAR

Detta avvisar varje värde som inte skalär. Med andra ord måste värdet vara en av följande datatyper: Boolean, heltal, flyttal, resurs (till exempel en databas länk eller fil handtag), eller sträng.

 

Konstanter, Flaggor & Alternativ

Nu ska jag gå igenom konstanter, flaggor och alternativ som används av filter funktioner för validering av data.

Syntaxen ser ut så här:

filter_var(variabel, filter_konstant, alternativ)

 

Längst ner på sidan finns en textfält där du kan testa dom olika konstanterna med filter_var.

 

  • Filterkonstant FILTER_VALIDATE_BOOLEAN
  • Flagga FILTER_NULL_ON_FAILURE

När det används utan flagga, returnerar den true för ’1’, ’true’, ’on’, och ”yes”; annars returners FALSE. Om FILTER_NULL_ON_FAILURE flaggan är satt, returnerar falskt endast för ’0’, ’falsk’, ’av’, ”nej”, och en tom sträng; Returneras NULL för alla icke-booleska värden.

Exempel:

// boolean koll med FILTER_VALIDATE_BOOLEAN
// När man använder filter_var utan en flagga, så returnerar den true bara för '1', 'true', 'on', och "yes"; annars false. 
// Om FILTER_NULL_ON_FAILURE flaggan är satt, returnerar den falskt bara för '0', 'false', 'off', "no", 
// och vid en tom sträng; Returnerar NULL för alla icke-booleska värden.
$var = FALSE;
// kolla om $var innehåller en boolean
$filtered = filter_var($var, FILTER_VALIDATE_BOOLEAN);
// ger svaret bool(false)
var_dump($filtered);

echo '<br />';

$var = 'true';
// kolla om $var innehåller en boolean
$filtered = filter_var($var, FILTER_VALIDATE_BOOLEAN);
// ger svaret bool(true) eftersom
// PHP är smart nog att tolka en sträng 
var_dump($filtered);

Resultatet:

bool(false) 
bool(true)

  • Filterkonstant FILTER_VALIDATE_EMAIL

Kollar att ett värde matchar med email formatet.

Exempel:

$var = 'mail@cr8gr8designs.com';
// kolla om $var innehåller en email
$filtered = filter_var($var, FILTER_VALIDATE_EMAIL);
var_dump($filtered);

Resultatet:

string(23) "mail@cr8gr8designs.com"

  • Filterkonstant FILTER_VALIDATE_FLOAT
  • Alternativ decimal
  • Flagga FILTER_FLAG_ALLOW_THOUSAND

Söker efter ett flyttal eller heltal; returnerar false för någon annan datatyp. Decimal alternativ tillåter användning av ett kommatecken som decimal. Inställning på flaggan accepterar siffror innehållande en tusentalsavgränsare (komma är standard, men punkt används när decimal är satt till ’,’). Funktionens returnerade värde alltid fråntagen tusentalsavgränsare, med en punkt som decimaltecken.

Exempel:

$var = 10.3;
// kolla om $var innehåller en float
$filtered = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($filtered);

echo '<br />';

$var = '10.3';
// kolla om $var innehåller en float
$filtered = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($filtered);

Resultatet:

float(10.3) 
float(10.3)

  • Filterkonstant FILTER_VALIDATE_INT
  • Alternativ min_range max_range
  • Flaggor FILTER_FLAG_ALLOW_OCTALFILTER_FLAG_ALLOW_HEX

Checks for an integer; returns false for any other data type. Specify the minimum and maximum acceptable values as an associative array using min_range and max_range (you can set just one or both together). Flags permit octal and hexadecimal numbers. Rejects numbers with a decimal point, even if the fraction is 0, for example, 10.0.

Exempel:

$var = 10;
// kolla om $var innehåller en integer
$filtered = filter_var($var, FILTER_VALIDATE_INT);
var_dump($filtered); // ger int(10)

echo '<br />';

$var = '10';
// kolla om $var innehåller en integer
$filtered = filter_var($var, FILTER_VALIDATE_INT);
// detta ger svaret int(10) då PHP tolkar en sträng som 
// bara innehåller siffror som en integer
var_dump($filtered);

Resultatet:

int(10) 
int(10)

  • Filterkonstant FILTER_VALIDATE_IP
  • Flaggor FILTER_FLAG_IPV4, FILTER_FLAG_IPV6, FILTER_FLAG_NO_PRIV_RANGE, FILTER_FLAG_NO_RES_RANGE

Kontrollerar att ett värde är en IP-adress. Flaggor låter dig ange endast IPv4 eller IPv6, eller inte från privata eller reserverade intervall.

Exempel:

$var = '192.168.1.1';
// kolla om $var innehåller en IP-adress
$filtered = filter_var($var, FILTER_VALIDATE_IP);
var_dump($filtered);

Resultatet:

string(11) "192.168.1.1"

  • Filterkonstant FILTER_VALIDATE_REGEXP
  • Alternativ regexp

Validerar ett värde mot en Perl- kompatibelt reguljärt uttryck. Hela värdet returneras, inte bara den del som matchar det reguljära uttrycket.


  • Filterkonstant FILTER_VALIDATE_URL
  • Flaggor FILTER_FLAG_SCHEME_REQUIRED, FILTER_FLAG_HOST_REQUIRED, FILTER_FLAG_PATH_REQUIRED, FILTER_FLAG_QUERY_REQUIRED

Kontrollerar att ett värde överensstämmer med formatet på en webbadress, eventuellt med nödvändiga komponenter som anges med flaggor.

Exempel:

$var = 'http://cr8gr8designs.com';
// kolla om $var innehåller en URL
$filtered = filter_var($var, FILTER_VALIDATE_URL);
var_dump($filtered); // ger string(24) "http://cr8gr8designs.com"

Resultatet:

string(24) "http://cr8gr8designs.com"

  • Filterkonstant FILTER_SANITIZE_STRING
  • Flaggor FILTER_FLAG_NO_ENCODE_QUOTES, FILTER_FLAG_STRIP_LOW, FILTER_FLAG_STRIP_HIGH, FILTER_FLAG_ENCODE_LOW, FILTER_FLAG_ENCODE_HIGH, FILTER_FLAG_ENCODE_AMP

Tar bort alla taggar, inklusive HTML, PHP och XML. Flaggorna ange alternativ för att ta bort eller avkoda specialtecken med en ASCIIvärde mindre än 32 (LOW) eller större än 127 (HIGH), lämna citationstecken okodade och avkoda et-tecken (&).

Exempel:

$var = "<this> <is> <a> </tag>utanför <script";
$filtered = filter_var($var, FILTER_SANITIZE_STRING);
var_dump($filtered);

Resultatet:

string(12) " utanför "

  • Filterkonstant FILTER_SANITIZE_STRIPPED

Detta är en alias av FILTER_SANITIZE_STRING som var precis innan den här.


  • Filterkonstant FILTER_SANITIZE_EMAIL

Tar bort alla tecken förutom bokstäver, nummer och dessa tecken:

! # $ % & ' * + - / = ? ^ _ ` { | } ~ @ . [ ]

Exempel på tecken som tas bort;

å Å ä Ä ö Ö fi ∂ é † √ ç ≈

Kod-exempel:

$var = 'lördag_när_hör_œ_åäö&@mäil.comåÅäÄöÖfi∂é†√ç≈';
$filtered = filter_var($var, FILTER_SANITIZE_EMAIL);
var_dump($filtered);

Resultatet:

string(22) "lrdag_nr_hr__&@mil.com"

  • Filterkonstant FILTER_SANITIZE_URL

Tar bort alla tecken förutom bokstäver, nummer och

$ - _ . + ! * ' ( ) , { } | \ ^ ~ [ ] ` < > # % " ; / ? : @ & =

Exempel:

$var = 'lördag_när_hör_œ_åäö&@mäil.comåÅäÄöÖfi∂é†√ç≈';
$filtered = filter_var($var, FILTER_SANITIZE_URL);
var_dump($filtered);

Resultatet:

string(22) "lrdag_nr_hr__&@mil.com"

  • Filterkonstant FILTER_SANITIZE_ENCODED
  • Flaggor FILTER_FLAG_STRIP_LOW, FILTER_FLAG_STRIP_HIGH, FILTER_FLAG_ENCODE_LOW, FILTER_FLAG_ENCODE_HIGH

URL-avkodar en sträng. Att ställa in flaggor tar valfritt bort eller kodar tecken med ASCII-värde på mindre än 32 (LOW) eller större än 127 (HIGH).

Exempel:

$var = 'lördag_när_hör_œ_åäö&@mäil.comåÅäÄöÖfi∂é†√ç≈';
$filtered = filter_var($var, FILTER_SANITIZE_ENCODED);
var_dump($filtered);

Resultatet:

string(176) "l%C3%B6rdag_n%C3%A4r_h%C3%B6r_%C5%93_%C3%A5%C3%A4%C3%B6%26%40m%C3%A4il.com%C3%A5%C3%85%C3%A4%C3%84%C3%B6%C3%96%EF%A3%BF%EF%AC%81%E2%88%82%C3%A9%E2%80%A0%E2%88%9A%C3%A7%E2%89%88"

  • Filterkonstant FILTER_SANITIZE_MAGIC_QUOTES

”Escapar” enkla och dubbla citationstecken, genom att sätta in ett bakstreck framför dem på samma sätt som de addslashes() funktion.


  • Filterkonstant FILTER_SANITIZE_NUMBER_FLOAT
  • Flaggor:
  1. FILTER_FLAG_ALLOW_FRACTION – Tillåter fraktions-avskiljare (som . )
  2. FILTER_FLAG_ALLOW_THOUSAND -Tillåter tusentals-avskiljare (som , )
  3. FILTER_FLAG_ALLOW_SCIENTIFIC -Tillåter vetenskaplig notation (som e och E)

Tar bort alla tecken utom siffror och plus och minustecken. Flaggorna valfritt tillåter en decimalbråk, tusentalsavgränsare, och vetenskaplig notation (med versaler eller gemener E). Decimalkommat och tusentalsavgränsare lämnas orörda. Om FILTER_FLAG_ALLOW_FRACTION inte är inställd, skall decimalkommat avlägsnas, men inte andelen, till exempel, 10,5 blir 105.

Exempel:

$var = '-hh12.44r__';
$filtered = filter_var($var, FILTER_SANITIZE_NUMBER_FLOAT);
var_dump($filtered);

Resultatet:

string(5) "-1244" // observera minus tecknet som följer med

Ett till exempel med flaggan FILTER_FLAG_ALLOW_FRACTION:

$var = '-hh12.4,4.02r__';
$filtered = filter_var($var, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);
var_dump($filtered);

Resultatet:

string(9) "-12.44.02"

  • Filterkonstant FILTER_SANITIZE_NUMBER_INT

Tar bort alla tecken utom siffror och plus och minustecken. Den decimal avlägsnas, om den finns, men inte andelen, till exempel, 10,0 blir 100.

Exempel:

$var = '-hh12.4,4.02r__';
$filtered = filter_var($var, FILTER_SANITIZE_NUMBER_FLOAT);
var_dump($filtered);

Resultatet:

string(7) "-124402" // observera minus tecknet som följer med

  • Filterkonstant FILTER_SANITIZE_SPECIAL_CHARS
  • Flaggor FILTER_FLAG_STRIP_LOW, FILTER_FLAG_STRIP_HIGH, FILTER_FLAG_ENCODE_HIGH

Omvandlas till HTML-entiteter enkla och dubbla citationstecken, <,>, &, och tecken med en ASCIIvärde mindre än 32. När Ställa in flaggor valfritt avlägsnar tecken med ASCIIvärde mindre än 32 (LOW) eller större än 127 (HIGH ), eller kodar tecken med ASCII värde större än 127.

Exempel:

$var = '<div>Innehåll & källkod</div>';
$filtered = filter_var($var, FILTER_SANITIZE_SPECIAL_CHARS);
var_dump($filtered);

Resultatet:

string(51) "<div>Innehåll & källkod</div>"

Om du kollar på källkoden för sidan, så ser det ut så här:

string(36) "&lt;div&gt;Innehåll &amp; källkod&lt;/div&gt;"

  • Filterkonstant FILTER_CALLBACK
  • Alternativ användar-definierad funktion eller metod

Anropar en användar-definierad function för att filtrera data.


  • Filterkonstant  FILTER_UNSAFE_RAW
  • Flaggor FILTER_FLAG_STRIP_LOW, FILTER_FLAG_STRIP_HIGH, FILTER_FLAG_ENCODE_LOW, FILTER_FLAG_ENCODE_HIGH, FILTER_FLAG_ENCODE_AMP

Gör ingenting.

Flaggorna anger alternativ för att ta bort eller koda specialtecken med en ASCIIvärde mindre än 32 (LOW) eller större än 127 (HIGH) och koda et-tecken (&).

Exempel:

$var = '<div>Innehåll & källkod</div>';
$filtered = filter_var($var, FILTER_UNSAFE_RAW);
var_dump($filtered);

Resultatet:

string(31) "
Innehåll & källkod
"

..och om man kollar på källkoden ser man det här:

string(31) ""
<div>Innehåll & källkod</div>
""

FILTER_UNSAFE_RAW exempel med flaggan FILTER_FLAG_STRIP_HIGH

$var = '<div>Innehåll & källkod</div>';
$filtered = filter_var($var, FILTER_UNSAFE_RAW, FILTER_FLAG_STRIP_HIGH);
var_dump($filtered);

Resultatet:

string(27) "
Innehll & kllkod
"

FILTER_UNSAFE_RAW exempel med flaggan FILTER_FLAG_STRIP_LOW

$var = '<div>Innehåll & källkod</div>';
$filtered = filter_var($var, FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_HIGH);
var_dump($filtered);

Resultatet:

string(51) "
Innehåll & källkod
"

Här nedanför kan du testa dom olika filterkonstanterna med filter_input() metoden. Koden kommer från boken ”PHP Object Oriented Solutions” av David Powers:


filter_id

Du kan även använda filter_id istället för konstanterna så här:

$var = 10;
$filtered = filter_var($var, filter_id('int'));
var_dump($filtered);

…och du får fram en lista över namn du kan använda med filter_list() metoden:

array(19) {
  [0]=> string(3) "int"
  [1]=> string(7) "boolean"
  [2]=> string(5) "float"
  [3]=> string(15) "validate_regexp"
  [4]=> string(12) "validate_url"
  [5]=> string(14) "validate_email"
  [6]=> string(11) "validate_ip"
  [7]=> string(6) "string"
  [8]=> string(8) "stripped"
  [9]=> string(7) "encoded"
  [10]=> string(13) "special_chars"
  [11]=> string(18) "full_special_chars"
  [12]=> string(10) "unsafe_raw"
  [13]=> string(5) "email"
  [14]=> string(3) "url"
  [15]=> string(10) "number_int"
  [16]=> string(12) "number_float"
  [17]=> string(12) "magic_quotes"
  [18]=> string(8) "callback"
}

Om vi tar en titt på filterkonstanten FILTER_SANITIZE_NUMBER_FLOAT med följande kod:

// där $_POST['number'] är lika med 1234.567
$filtered = filter_var(INPUT_POST, 'number', FILTER_SANITIZE_NUMBER_FLOAT);
var_dump($filtered);

Detta kommer att ge resultatet:

string(6) "123456"

Det här oväntade resultat får man eftersom sanerings filtret endast avlägsnar olagliga eller oönskade tecken. För att styra den mer exakt, måste man använda lämpliga flaggor och alternativ. Så, låt oss ta en titt på hur du lägger till flaggor och alternativ till ett filter.


Flaggor & alternativ

Det är här saker och ting börjar bli komplicerade. Formatet på den sista valfria argumentet till filter_input() och filter_var() beror på om vi vill använda flaggor, alternativ, eller både och. Dom tillgängliga alternativen och flaggorna har vi precis gått igenom. Syntaxen för att lägga till flaggor och alternativ ser likadan ut för både filter_input() och filter_var():

$var = 1234.56;
// filter_var($variabel, KONTANT, FLAGGA)
$filtered = filter_var($var, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);

Man kan lägga till flera flaggor åt gången, som då separeras med vertikalstreck|. Så för att tillåta tusentals-avskiljare på förra exemplet gör man så här:

$var = 1234.56;
// filter_var($variabel, KONSTANT, FLAGGA1 | FLAGGA2)
$filtered = filter_var($var, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION | FILTER_FLAG_ALLOW_THOUSAND);

Alternativ

Alternativ måste vara en flerdimensionell associativ array med nyckel värde par, där arrayn i den översta nivån har nyckeln ”option”. Så ta t.ex. FILTER_VALIDATE_INT som accepterar alternativen min_range och max_range. För att acceptera heltal bara mellan 10 och 100 (inklusive), lägger man till dessa alternativ:

$var = 17; $filtered = filter_var($var, FILTER_VALIDATE_INT, array('options' => array('min_range' => 10, 'max_range' => 100)));

Alternativen är alltså den här arrayn:

array('options' => array('min_range' => 10, 'max_range' => 100))

Både Flaggor & Alternativ

För att lägga till både flaggor och alternativ måste flaggorna in i den multidimensionella arrayn. Så för att tillåta tusentals-avskiljare på förra exemplet gör man på det här sättet:

$var = '1234.567';
$filtered = filter_var($var, FILTER_VALIDATE_FLOAT, array('options' => array('decimal' => ','), 'flags' => FILTER_FLAG_ALLOW_THOUSAND));

 

Att tänka på – Även om FILTER_VALIDATE_FLOAT accepterar siffror i europeisk stil med komma istället för punkt, när lämpligt alternativ och flagga är inställd, så blir värdet som returneras av filtret alltid med en punkt som decimal och den avlägsnar eventuella tusentalsavgränsare. Ett blanksteg accepteras inte som tusentalsavgränsare.


Flera variabler åt gången

För det mesta, behöver du filtreringen och valideringen att hantera flera variabler åt gången. För att undvika att behöva anropa filter_input() eller filter_var() funktionerna flera gånger finns motsvarande funktioner som kan bearbeta många variabler på samma gång: filter_input_array() och filter_var_array().

filter_input_array() tar följande argument:

  • $source: Detta indikerar vilken superglobal array som innehåller dom variabler man vill filtrera. M måste använda en av de konstanter som vi gick igenom i början.
  • $instructions: Detta är en valfri flerdimensionell array som anger hur variabler ska filtreras. Om det här argumentet utelämnas, används standardfiltret tillämpas (jag går igenom hur man ställer in standardfiltret lite senare i artikeln).

 

filter_var_array() tar följande argument:

  • $data: En array som innehåller de variabler man vill filtrera eller validera.
  • $instructions: Samma som för filter_input_array().

 

Sättet man skapar den flerdimensionella arrayn för det andra argumentet är mycket hur man ställer in flaggorna och alternativen för att filtrera enskilda variabler. På den översta nivån av arrayen bör det finnas ett element för var och en av de variabler som skall bearbetas. Det värde som tilldelas varje variabel ska antingen vara en filterkonstant eller en array som innehåller en kombination av följande: ”filter”, ”options” och ”flags”.

Här ser du exempel på alla varianter:

// kodexemplet kommer från boken "PHP Object Oriented Solutions" av David Powers
$data = array(
    'age'       => 39
    'rating'    => 5,
    'thousands' => '100,000.95',
    'european'  => '100.000,95');
);
$instructions = array(
    'name' => FILTER_SANITIZE_STRING,
    'price' => array('filter' => FILTER_VALIDATE_INT,
        'options' => array('min_range' => 1,
            'max_range' => 5)),
    'thousands' => array('filter' => FILTER_SANITIZE_NUMBER_FLOAT,
        'flags' => FILTER_FLAG_ALLOW_FRACTION |
        FILTER_FLAG_ALLOW_THOUSAND),
    'european' => array('filter' => FILTER_VALIDATE_FLOAT,
        'options' => array('decimal' => ','),
        'flags' => FILTER_FLAG_ALLOW_THOUSAND)
);
$filtered = filter_var_array($data, $instructions);

…och för att använda det här med filter_input_array() istället byter man bara ut den första parametern till en av superglobal konstanterna på det här sättet:

$filtered = filter_input_array(INPUT_POST, $instructions);

Som du ser blir detta väldigt krångligt och man råkar garanterat ut för en massa undantag (exeption). Nu kommer OOP till undsättning och man kan gömma den här komplexiteten bakom en klass.


Ställa in standard

Om du använder en typ av filter övervägande, kan du ange en standardfilter och även standardflaggor. Det finns tre ställen du kan göra detta: i php.ini; eller, om du använder en Apache-server, i Apaches konfigurationsfil httpd.conf, eller en .htaccess fil.

Konfigurations direktiv som behöver ändras är följande:
filter.default : Detta bör följas av en sträng med ett av namnen som genereras av filter_list() (se högre upp i artikeln).
filter.default_flags : Detta bör vara en av flaggkonstanterna. För att ställa in fler än en flagga, separera varje konstant med en enda vertikalstreck |. För att ställa in standardinställningarna i php.ini, tar man bort semikolonet från början av raden som innehåller den direktiv man vill använda, och lägger värdet efter likhetstecknet. Med följande direktiv ställer du in som standard att konvertera till HTML-entiteter, enkla och dubbla citattecken, större än, mindre än, och et-tecken &, medan standardflaggor bort alla tecken med ASCII värde på mindre än 32 eller större än 127:

filter.default = special_chars
filter.default_flags = FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH

För att ställa in värdena i httpd.conf eller en .htaccess fil, används php_value, följt av direktivet och dess värde som en mellanslags separerad lista såhär:

php_value filter.default special_chars
php_value filter.default_flags FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH

Okej, nu räcker det för den här gången. Vi fortsätter nästa gång med att bygga en valideringsklass. Tack för visat intresse och koda smart 😉

OOP PHP

Inspiration och fria översättningar från ”PHP Object Oriented Solutions” av David Powers.

I början av 60 talet började man inse att det var ohållbart att försöka uppdatera, felsöka och utveckla stora och komplexa applikationer med procedural/sekventiell kod som exekveras rad efter rad då detta var väldigt tidsödande och svårt.

Lösningen var att flytta funktionerna bort från huvudscriptet, och sedan klumpa ihop sammanhörande funktioner i logiska enheter som representerade en större och mer allmän ”kugghjul” i applikationen, dessa block kom att kallas för klasser och innehåller oftast metoder (funktioner i klasser kallas för metoder) och medlemsvariabler (även kallade egenskaper, attribut eller fält, i fortsättningen egenskaper) som används för att modifiera ett state av ett objekt (som är en instans av en klass).

Man skulle kunna göra jämförelsen med assemblerprogrammering och högnivåspråk, där den senare har en högre abstraktionsnivå och detsamma gäller med förhållandet mellan procedural kod och att arbeta med klasser och tillhörande metoder där en klass fungerar som en fabrik och varje metod är en avdelning som utför en specifik uppgift.

Så varför är det så bra med OOP sättet att programmera? Jo, genom att skapa så generiska moduler som möjligt får man fram script som är återanvändningsbar och så klart blir det mycket lättare att underhålla scripten.

Skydda dataintegritet » inkapsling

Inkapsling betyder att man ser till att varje enskild del av applikationen är avskilt från varandra och på det sättet inte kan störa (förutom genom angivna metoder). På detta sätt undviker man dominoeffekten som uppstår vid close coupling, så man bör eftersträva loose coupling. Man anger synlighet för egenskaper med tre olika nyckelord: public, private och protected, public är synlig från andra cript innanför och utanför klassen, protected och private o andra sidan är inte synliga utanför klassen och kan därför inte modifieras godtyckligt. Man kan även ange dessa nyckelord för metoders synlighet, på detta sätt och genom välplanerad struktur skyddar man viktiga egenskaper och funktioner i en applikation.

Exempel på public, private och protected egenskaper:

public $var1;
// både private och protected egensksnamn -
// föregås av dollartecken & understreck
private $_var2;
protected $_var3;

 

Polymorfism

Betyder egentligen bara att man får använda samma namn på liknande metoder och egenskaper (i kombination med inkapsling). För att illustrera polymorfismens funktionalitet kan vi ta ett exempel; ett människohuvud har en helt annan form än ett fågelhuvud, men dom har båda ungefär samma funktioner d.v.s. äta, andas, prata, se och så vidare, och därför är det vettigt att använda samma namn på båda. OOP PHP tillämpar detta till programmering genom att låta dig ge samma namn till metoder och egenskaper som spelar liknande roller i olika klasser.

Varje klass och objekt är oberoende, så dess metod- och egenskapsnamn är nära förknippade med klassen och alla objekt som skapats från den. Därför finns ingen risk för konflikter, så när en metod eller egenskap används på liknande sätt i olika klasser, är det vettigt att använda samma namn på dom.

Utöka klasser genom arv

När hjulet har uppfunnits, finns det ingen anledning att återuppfinna det – men man kan förbättra det, eller anpassa den för specialiserade användningsområden, så det finns ingen anledning att koda allt från grunden; man kan basera en ny klass på en befintlig.

Precis som du har ärvt vissa egenskaper från dina föräldrar, och utvecklat nya som tillhör dig, kan ett barn klass eller subklass i OOP ärva alla funktioner i sin moderklass (eller superklass), anpassa vissa av dem, och lägga till nya av sina egna.

Man kan utöka alla klasser, inbyggda, tredjepart eller egna men inte klasser som är deklarerade som final.

Underklassen ärver automatiskt alla egenskaper och metoder från sin superklassen, vilket kan vara en stor tidsbesparing om superklassen innehåller en hel del komplex kod. Du kan inte bara lägga till nya metoder och egenskaper, utan du kan också ”skriva över” befintliga metoder och egenskaper (detta är polymorfism i praktiken), anpassa dem till behoven hos den nya klassen.

Så hur ska man välja vad man utökar och vad man bygger från grunden? Jo, precis som det är tänkt med OOP så skapar man generiska klasser från grunden och utökar funktionaliteten för mer specifika klasser.

Loose Coupling

Loose coupling syftar ju som tidigare sagt till tekniken att skapa kod som inte är beroende av annan kod i applikationen genom att ange klara och individuella uppgifter till klasser och därmed inte kan störa andra delar av appen (förutom genom strikt angivna regler).

Loose coupling tekniken går ut på att så långt som mjöligt undvika utveckling för ett specifikt projekt, men det blir i slutändan oundvikligt att skriva metoder som riktar sig till specifika områden och kommer inte att kunna användas i andra applikationer. Tänk så här; när du skapar en klass, fråga dig själv om tekniken skulle kunna användas i andra projekt, om det kan så bör du göra klassen loose coupled d.v.s. så generisk som möjligt.

Design mönster

Många av dom problem som du ska lösa har andra utvecklare garanterat stött på tidigare. Om du hittar ett beprövat sätt att ta hand om ett problem så bör man ta efter lösningen.  Denna typ av kunskap har fått ett namn; design mönster. Ett design mönster är dock inte ett kodblock utan beskriver ett sätt att hantera ett problem.

Utvecklingen av OOP i PHP

Som sagt är PHP ingen OOP språk utan har OOP lösningar. Man började införa OOP i PHP version 3 men det fattades många essentiella funktioner där det största problemet var hur PHP hanterade variabler. Tyvärr fixades inte dom problemen under version 4 eftersom fokus låg på bakåtkompatibilitet.

Tillägget för OOP stöd var oväntad populär, men att fixa tidigarenämnda problemen skulle innebära att att existerande script skulle ”gå sönder”, men när PHP 5 släpptes Juli 2004 gjorde man detta ändå och det blev en radikal förändring av språket.

PHP: s hantering av föremål blev helt omskriven i PHP 5 för att förbättra prestanda och uppfylla kraven i standarder som är gemensamma för andra OOP språk. Den största förändringen från PHP 3 och 4 är det sätt objekt och deras egenskaper hanteras. Ta exemplet nedan:

$objectB = $objectA;

I PHP 3 och 4, skapar detta en kopia av $objectA och lagrar det som $objectB. Båda objekten agerar därefter oberoende av varandra; ändringar som gjorts i $objectA påverkar inte $objectB, och vice versa. Detta är känt som kopiering av värde och är sättet som PHP normalt hanterar variabler.

Men med PHP 5, istället för att göra en kopia av $objectA, lagras en referens till $objectA i $objectB. Båda variablerna refererar då till samma objekt; ändringar som görs i den ena påverka den andra. Detta är känt som kopiering genom referens. Sedan PHP 5, måste man, för att göra en kopia av ett föremål, använda nyckelordet clone:

$objectB = clone $objectA;

clone används endast med objekt (instanser av klasser), medan alla andra variabler fungerar på samma sätt som i PHP 4, det vill säga att man anger ett värde med tilldelnings operatorn för att skapa en kopia.

Andra viktiga skillnader i PHP5:

  • Synlighetsmodifierare som används för att styra åtkomst till egenskaper och metoder (Viktiga för inkapsling)
  • En enhetlig konstruktor namn,  __construct() istället för en metod med samma namn som klassen.
  • Stöd för explicit sanering av resurser genom en destructor funktion __destruct()
  • Stöd för gränssnitt (interface) och abstrakta klasser
  • final klasser
  • Statiska (static) egenskaper och metoder
  • Automatisk laddning av klasser

Utvecklingen av PHP 6 var under utveckling under en lång tid, och ursprungligen var det beräknat att komma ut i början av 2007, men som det ser ut nu kommer ingen version 6 över huvudtaget, utan man hoppar till 7 direkt (som man började jobba på 2014) mest p.g.a. att man vill slippa förvirringen kring gamla referenser till PHP 6, i böcker och artiklar.

Projektet PHP 6 övergavs officiellt Mars 2010 †

Artiklar om frågan PHP 6 / PHP 7;

 

 

Teckenkodning i PHP

Strängar som har tecken med accenter kan orsaka problem p.g.a. olika teckenkodningar, och detta i PHP speciellt.

Ta följande exempelkod som skriver ut En god dag, Världen!” i åtta olika språk:

<?php
echo '<div style="width:500px;margin:100px auto;text-aling:center;">';
echo '<h1>En god dag, Världen!<br />';
echo 'A good day, World!<br />';
echo 'Schönen Tag, Welt!<br />';
echo 'Une bonne journée, tout le monde!<br />';
echo 'يوم جيد، العالم<br />';
echo '좋은 일, 세계!<br />';
echo 'Một ngày tốt lành, thế giới!<br />';
echo 'こんにちは、世界!';
echo '</h1></div>';

 

Exempel på fel som uppstår vid teckenkodnings problem i PHP.
Figur 1-1 Exempel på fel som uppstår vid teckenkodnings problem.

Om man använder tecken med accenter kan detta skapa problem vid utskrift. Den allra vanligaste teckenkodningen på webben idag är UTF-8 som är satt som webbstandard av W3C, eftersom den har stöd för så gott som samtliga tecken. Om vi ändrar charset till UTF-8 med hjälp av en content-type header så försvinner problemet.

Lägg till följande kod precis efter start-taggen;

<?php
header('Content-Type: text/html; charset=utf-8');
Content-type header charset UTF-8
Figur 1-2 Efter att ha ändrat charset till UTF-8, med content-type header.

 

Om du skulle få problem med utskriften, kan du fixa det genom att lägga till en Content-type header i början av filen (eller ännu hellre i en initierigs-fil som sköter det nödvändiga inställningarna och laddningarna av resurser för att applikationen ska fungera som den ska), som då talar om vilken teckenkodning du vill använda.

En mycket bra artikel om teckenkodning, som jag tycker att du bör läsa;

Strängar är aningen speciella i PHP, och vill du läsa mer om Strängar hittar du allt om dom i dokumentationen, och då speciellt avsnittet ”Details of the String Type”;

…här är en liten, fritt översatt urdrag från den;

”Med tanke på att PHP inte har en specifik teckenkodning för strängar, kan man undra hur stränglitteraler är kodade…  [ ]  …Svaret är att strängar kodas på det sätt som dom kodades i skriptfilen. Således, om skriptet är skrivet i ISO-8859-1,  kommer strängen att kodas i ISO-8859-1 och så vidare.”

 

Gör skillnad på stora & små

Även om PHP inte ser någon skillnad på små och stora bokstäver i funktions- och klassnamn, ska du alltid tänka som att den gör det, eftersom det finns planer på att göra dem skiftlägeskänsliga på samma sätt som variabler.

Bygga klasser

Okej då var det dags att fortsätta med att bygga en klass. Vi börjar med en enkel exempel-klass som mest innehåller kommentarer som förklarar allt:

// dok_test.class.php
// här namnger jag filen med .class för att indikera
// att det handlar om en klass
class Dok_Test {
	// medlemsvariabel deklaration där variabelnamn -
	// föregås alltid av nyckelordet: public, protected eller private.
	// Om man anger ett startvärde får inte det vara beroende av kod
	// som kan förändras under exekvering, så värdet kan inte vara en metod.
	// private och protected börjas med understreck » $_namn
	// för att indikera att åtkomst är begränsad
	protected $_var;
	protected $_val;

	/**
	* metod deklaration
	* Använder $this nyckelordet för att referera till den här klassen
	*/
	public function displayProp() {
		// Man utelämnar $ i $_val då man använder $this
		// som pekar på den här klassen » Dok_Test
		echo $this->_val;
	}
}

Som du såg måste en medlemsvariabel föregås av ett synlighets nyckelord; public, protected eller private och om man använder protected eller private ska man ha understreck efter dollartecknet $_  följt av namnet, vilket hjälper utvecklaren att enkelt se vilken synlighet den har.

Så, vad ska man välja? Metoder fungerar ju som klassens reglage, och behöver därför oftast vara public, medan medlemsvariabler bör skyddas med protected eller private så att man inte kommer åt dom oavsiktligt. För att modifiera egenskaper använder man sig av getter och setter metoder.

Exempel på setter och getter metoder:

class Dok_Test {
    protected $_var;
    protected $_val;

    public function displayProp() {/* ..innehåll */}

	/**
	* För att kunna ändra på värdet av $val som är protected
	* måste man skapa en s.k. setter metod
	*/
	public function setValues($newVal, $newVar) {
		// sätt värde för protected $_val till $newVal
		$this->_val = $newVal;
		$this->_var = $newVar;
	}

	/**
	* Och för att kunna komma åt värdena för $val & $var
	* skapar man en getter metod
	*/
	public function getValues() {
		// return värdet på $val och $var som en array()
		return array($this->_val, $this->_var);
	}
}

För att använda en klass i ett script  måste man inkludera det, och likt funktioner kan klasser bara definieras en gång i ett script så det är vettigt att använda någon av; include_once och require_once metoderna för att bara ladda in den en gång i scriptet och undvika en ”Fatal error”.

För att använda en klass behöver man som sagt inkludera det, och sedan skapa en instans av den med hjälp av nyckelordet new;

// test.php
// inkludera klassen
include_once("dok_test.class.php");

// skapa en ny instans av Dok_Test
$obj = new Dok_Test();

// anropa metod från klassen som skriver ut -
// värdena för medlemsvariablerna
$obj->displayProp();

 

 

protected & private metoder

Det finns lägen då man inte vill att en viss metod ska vara tillgänglig utanför klassen (vilket man också ska eftersträva för att uppnå inkapsling, och med det avskilda delar), då begränsar man dess synlighet med nyckelordet; private eller protected:

class Dok_Test {
	protected $_var;
	protected $_val;
	private $_secret = 1234;

	public function displayProp() {/* ..innehåll */}
	public function setValues($newVal, $newVar) { /* ..innehåll */ }
	public function getValues() {/* ..innehåll */ }
	
	protected function setValue($val) {
		$this->_secret = $val;
	}
	/**
	* 
	* 
	*/
	public function initiateConnection($new_val) {
		if(is_numeric($new_val)) {
			$this::setValue(htmlspecialchars($new_val));
		}else {
			return;
		}
	}
}

Nu kan vi skapa en ny objekt och ange värden för båda medlemsvariablerna, eller lämna ut det:

// skapa ny objekt
$test = new Dok_Test();

// sätt värde för medlemsvariablerna
$test->setValue("Ny värde för _var", 1999);

// man använder print_r() och metoden getValues()
// för att skriva ut värdena från en array
print_r($test->getValue());

 

Vad vi har gått igenom hittils:

  • Det man kan göra med objekt står metoderna för och det man lagrar görs i egenskaper.
  • Alla egenskaper måste deklareras med, och föregås av en synlighetsnyckelord; public, protected eller private (detta gäller inte static medlemsvariabler som vi går igenom senare).
  • Att använda synlighetsnyckelord är valfritt när man definierar en metod, men det är rekommenderat att använda ett. Om inget anges, kommer metoden att ses som public.
  • Metod är ett ord för en funktion inne i en klass.
  • Man måste inkludera klassfilen för att kunna använda den. Man bör använda include_once eller require_once för att undvika att omdefiniera klassen, vilket utlöser en ”Fatal error”.
  • Skapa en instans av en klass, d.v.s. ett objekt med nyckelordet new.
  • $this variabeln; när den används i en klass, refererar till nuvarande objekt.
  • Använd -> operatorn för att komma åt en objekts metoder eller medlemsvariabler.
  • Om man försöker använda protected eller private medlemsvariabler från ett script utanför klassen, kommer scriptet att utlösa en ”Fatal error”.
  • Använd getter och setter metoder för att komma åt protected och private medlemsvariabler och metoder.

private – kan endast nås INIFRÅN klassen.

protected – kan nås från INOM klassen och av ÄRVDA klasser.

public – kan kommas åt från kod UTANFÖR och innanför klassen.

Detta gäller för funktioner och variabler.

Sätt standardvärden med konstruktor

Om du har programmerat i någon annan OOP språk som t.ex. Java, känner du säkert till konstruktor metoder. Dom heter oftast samma som klassen men i PHP har man ett enhetligt namn för den; construct (den hette samma som klassen i tidigare versioner av PHP).

construct anropas automatiskt när ett objekt skapas av en klass, och det är gotdytckligt vilken kod du lägger i metoden, men vanligen är det kod som initierar objektet genom att ge standardvärden till medlemsvariabler och anropa metoder.

Vi skriver in en __construct metod i vår klass:

class Dok_Test {
	protected $_var;
	protected $_val;

	/**
	* __construct() körs automatiskt vid -
	* skapande av ny instans av Dok_Test()
	* Den har default värden på båda medlemsvariablerna -
	* så att man kan utelämna dom vid skapande av det ny objektet
	*/
	public function __construct($val = 0, $var = '') {
		// initiera egenskaperna
		$this->_val = 0;
		$this->_var .= " som detta konkateneras vid skapande av nytt objekt";
	}

	public function setValues($newVal, $newVar) { /* ..innehåll */ }
	public function getValues() { /* ..innehåll */ }
	public function displayProp() { /* ..innehåll */ }
}

Observera att den har två understreck i början. Construct metoden används enbart vid skapande av ny objekt, så den bör inte returnera något.

 

__destruct()

Det finns även en __destruct() metod som anropas automatiskt när ett objekt förstörs. I metoden kan man då avsluta saker som inte behövs längre, som att stänga öppna filer, eller databaser.

$this & self::

Använd $this för att hänvisa till det aktuella objektet. Använd self för att hänvisa till den aktuella klassen. $this refererar till en instans av en klass. Men det finns också något som kallas statiskt tillstånd, vilket är densamma för alla förekomster av den klassen. self:: är åtkomst nyckelordet för dessa attribut och funktioner.

Definitioner:

  • Class – detta är en användardefinierad datatyp, som omfattar lokala funktioner samt tillhörande lokal data i form av egenskaper. Du kan tänka på en klass som en mall för att göra många exemplar av samma typ av objekt   (instans av klass).
  • Objekt – en individuell instans av datastrukturen som definieras av en klass. Du definierar en klass en gång och gör sedan så många objekt du behöver, vilka härrör från klassen. Objekt är också kända som instanser av klasser.
  • Objekt Ortienterad Programmering – betyder att man klumpar ihop funktionalitet som hör ihop i klasser som kan innehålla medlemsvariabler och funktioner som man modifierar instanser av klassen genom objekt som skapats av klasserna.
  • Medlemsvariabler – dessa är de variabler som definierats i en klass. Denna data kommer att vara osynlig utanför klassenen men kan nås via medlemsfunktioner. Dessa variabler kallas för egenskaper av objektet när ett objekt har skapats.
  • Medlemsfunktioner – dessa är funktioner definierade i en klass och används för att komma åt data som hör till  objektet.
  • Close coupling – kod som är sammanlänkad och beroende av de olika delarna i applikationen.
  • Loose coupling – kod som inte är beroende av varandra och skrivs i individuela block
  • Procedural  – betyder att koden läses rad efter rad i ett linjärt flöde
  • Arv – När en klass definieras genom utökning av en befintlig föräldraklass, så det kallas det för nedärvning (inheritance). En barn-klass ärver alla eller några medlemsfunktioner och variabler från dess förälder-klass.
  • Förälder-klass – en klass som en barn-klass ärver från. Detta kallas också en basklass eller superklass.
  • Barnklass – en klass som ärver från en annan klass. Detta kallas också en subklass eller deriverad klass.
  • Subklass – är en barnklass.
  • Superklass – är en förälderklass
  • Extend –  en barnklass extend en förälderklss.
  • Data Abstraktion – en representation av data där detaljerna av genomförandet är dolda (abstraherade).
  • Query – Syftar till söknings strängar som används för att hämta databas poster som matchar angivna kriterier, t.ex. ”SELECT * FROM users ORDER BY id”
  • Polymorfism – detta är ett objektorienterat koncept där samma funktion kan användas för olika ändamål. Till exempel funktionsnamn förblir desamma men det kan ta olika antal argument och kan göra olika uppgifter.

Skapa en slider med Cycle2

Idag ska vi skapa en slider med Cycle2 som är ett jQuery tillägg. Det första du behöver är jQuery och Cycle2. Sedan skapar du ett nytt projekt med din favorit textredigerare (bra alternativ » Sublime Text 2Aptana Studio & NetBeans). Du ska skapa två mappar i roten av projektet; css & js där js ska innehålla jQuery och Cycle2, i css skapar du en ny stilmall, t.ex. style.css och till sist ett HTML dokument i roten av projektet; index.htm.

 

Enkel att använda…

Cycle2 är super enkel att använda och jag blev kär vid första slidern! Du behöver inte koda en rad JavaScript utan allt tas om hand av Cycle2 genom uppmärkning och HTML data attribut. Till en början ska vi markera upp index.htm med en div runt alla bilderna:

<!doctype html>
<html lang="sv-SE">
<head>
	<meta charset="UTF-8" />
	<title>Cycle2 Slider | cr8gr8designs.com</title>
	<meta name="author" content="Daniel Karjanlahti" />
	<meta name="keywords" content="Cycle2, Slider, jQuery, data-attribute" />
</head>
<body>
	<div id="slider">
	     <img src="res/blackwhiteintel.jpg" />
	     <img src="res/colorring.jpg" />
	     <img src="res/fairymeetsalien.jpg" />
	     <img src="res/futureworkstation.jpg" />
        </div>

<!-- och så klart jQuery & Cycle2 -->
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<script src="http://malsup.github.com/jquery.cycle2.js"></script>
</body>
</html>

Vi placerar slidern i mitten av sidan och sätter position till relative så att dess barn (img) kan placeras absolute. och vi sätter även overflow till hidden för #slider så att bilderna inte sticker ut:

#slider {
	position: relative;
	width:1024px;
	height:546px; 
	margin: 60px auto; 
	overflow: hidden;
}
img {
	position: absolute;
	width: 100%;
	height: 100%;
}

…och till sist Cycle magi genom att ge den omslutande div#slider klassnamnet:

cycle-slideshow som kommer att indikera för Cycle2 att det är här vi har en div som innehåller bilder

och en data attribut »

data-cycle-fx (som anger hur slidern växlar bild)

med värdet scrollHorz som betyder scrolla horisontellt

…och data-cycle-timeout (som anger frekvensen för hur ofta bilden ska växlas)

med värdet 3000 millisekunder (3 sekunder).

<div id="slider" class="cycle-slideshow"
	data-cycle-fx="scrollHorz"
	data-cycle-timeout="3000">

	<img src="res/blackwhiteintel.jpg" />
	<img src="res/colorring.jpg" />
	<img src="res/fairymeetsalien.jpg" />
	<img src="res/futureworkstation.jpg" />
</div>

 

Hela koden

Och här kommer hela koden till slidern.

HTML

<!doctype html>
<html lang="sv-SE">
<head>
	<meta charset="UTF-8" />
	<title>Hem | cr8gr8designs.com</title>
	<meta name="author" content="Daniel Karjanlahti" />
        <meta name="keywords" content="Cycle2, Slider, jQuery, data-attribute" />
</head>
<body>
	<div id="slider" class="cycle-slideshow"
		data-cycle-fx="scrollHorz"
		data-cycle-timeout="3000">

		<img src="res/blackwhiteintel.jpg" />
		<img src="res/colorring.jpg" />
		<img src="res/fairymeetsalien.jpg" />
		<img src="res/futureworkstation.jpg" />
	</div>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<script src="http://malsup.github.com/jquery.cycle2.js"></script>
</body>
</html>

CSS

#slider {
	position: relative;
	width:1024px; /* bredden på bilderna */
	height:546px; /* höjden på bilderna */
	margin: 60px auto; 
	overflow: hidden;
}
img {
	position: absolute;
	width: 100%;
	height: 100%;
}

Som sagt ingen JavaScript och nu ska din nya slider fungera, lätt som en plätt!

Demo slider » här

Ladda ner källkoden » cycle2_slider_demo

 

 

Länk på bilderna

Du kan även länka bilderna genom att omsluta bilderna med en ankar-tagg och sedan ange data attributet data-cycle-slides i den omslutande div elementet med klassen cycle-slideshow och ge den värdet ”> a”:

<div class="cycle-slideshow" 
    data-cycle-fx="scrollHorz" 
    data-cycle-timeout="2000"
    data-cycle-slides="> a">

    <a href="http://cr8gr8designs.com">
        <img src="res/bild.jpg" >
    </a>
    <a href="http://cr8gr8designs.com">
        <img src="res/bild.jpg" >
    </a>
    <a href="http://cr8gr8designs.com">
        <img src="res/bild.jpg" >
    </a>
</div>

 

Slider med textinnehåll

Det går att skapa en slider med textinnehåll genom att ange data attribut data-cycle-slides i omslutande div elementet och ge den värdet ”> element” där ”mer än” tecknet efterföljs av elementet. Här kommer koden för en slider som har textinnehåll:

<div id="slider" class="cycle-slideshow"
data-cycle-fx="scrollHorz"
data-cycle-timeout="3000"
data-cycle-slides="> div">
	<div><!-- Hit ska textinnehållet --></div>
	<div><!-- Hit ska textinnehållet --></div>
	<div><!-- Hit ska textinnehållet --></div>
	<div><!-- Hit ska textinnehållet --></div>
</div>

 

Extra funktioner

Det finns en massa funktioner till Cycle2 och alla fungerar genom att man lägger till data attribut av specifikt slag, och som jag sa tidigare anger data-cycle-fx hur slidernväxlar bild, dvs. om bilden ska glida åt sidan, zooma in, zooma ut, + många fler, och här nedanför ser du ett gäng olika värden för data-cycle-fx:

scrollHorz » glider åt sidan
carousel   » bilderna ligger i en rad och glider åt sidan
flipHorz   » flippar runt bilden horisontellt
flipVert   » lippar runt bilden vertikalt
shuffle    » byter bild genom att den "blandar" bilderna
tileSlide  » remsor som faller ner
tileBlind  » persienn som vänds kan modifieras ytterligare genom att särtta data-cycle-tile-vertical till false och ange antal remsor med data-cycle-tile-count

 

Pager

Man kan lägga till en pager genom att först skapa en div:

<div class="cycle-pager"></div>

…och sedan ange ytterligare data attribut i cycle-slideshow diven:

data-cycle-pager=".cycle-pager"

Och så vidare du hittar alla dom olika attributen på Cycle2’s hemsida.

 

HTML till Drupal Tema

Artikeln finns som PDF bok här »  HTML till » Drupal 7 Tema den är mycket mer genomgående och snyggare!

Förberedelser

Idag ska vi omvandla HTML till Drupal Tema och vi kör igång på en gång, utan att hänga kvar vid en massa bakgrund, för du har ju redan bestämt dig för att lära dig hur man omvandlar en statiskt HTML till » Drupal tema som är en dynamisk PHP & JavaScript baserad CMS, så grunderna i webbutveckling som, HTML & CSS borde du kunna…

 

Utvecklingsmiljön

Som en utvecklare är det viktigt att ha en bra utvecklingsmiljö och du kan hitta en massa bra tips på Drupal.org. Vi ska installera Devel, ett mycket populärt verktyg som kan generera noder (innehåll), användare, kommentarer, termer och mycket annat snabbt och enkelt, så logga in i din Drupal installation och navigera dig till Modules och installera Devel, gå sedan tillbaka till Modules och aktivera den genom att kryssa i “ENABLED” och scrolla längst ner på sidan och spara genom att klicka på “Save configuration”.

 

“Dummy” innehåll

Vi börjar med att skapa en del dummy innehåll så att vi kan se hur sidan kommer att se ut med riktigt innehåll, så navigera dig till Configuration » Development » Generate content, här har du antagligen bara två möjligheter; Article & Basic page, och det är artiklar som ska börja med. Jag ska skapa 50st på en gång Vi skapar även ett par sidor; Portfolio, Webb, Om oss & Kontakt.

 

Verktyg

Jag kommer att använda Aptana Studio för att skapa temat eftersom den lämpar sig väl till PHP projekt och har mycket bra kodkomplettering, men Netbeans är också väldigt bra kandidat för ett PHP projekt. Den andra viktiga verktyget är webbläsaren! Min favorit är Chrome som har utvecklingsverktyg installerade som standard, men en spännande nyhet är Firefox Developer Edition som är en webbläsare dedikerad för webbutveckling

 

Skapa projektet

 

Vi börjar med att skapa en bas för temat, som består av en ny PHP-projekt och den ska vi placera under drupal/sites/all/themes för det är där som Drupal kommer att leta efter det nya temat (inte i drupal/themes som innehåller kärnteman som kommer med i installationen), themes mappen kommer inte att finnas från början så du får skapa den. Jag kommer att kalla mitt tema för cr8gr8designs efter min hemsida (cr8gr8designs.com).

 

.info

Den första filen vi ska skapa är en .info fil som ska heta samma som temat, så i mitt fall blir det cr8gr8designs.info och i den ska vi skriva in följande:

 

name = cr8gr8designs
description = En tema för Drupal 7
core = 7.x
version = 1.0
engine = phptemplate

 

Name

Name är ju rätt självförklarande, och är namnet på temat

 

Description

Description är en beskrivning av temat,

 

Version

Version är tema version vilket kan vara bra speciellt nu i utvecklingsskedet då man gärna vill se förändringar man gör (man kan också tömma cache i admin delen av Drupal)

 

Core (Drupal kompatibilitet)

Sedan har vi core som anger vilken Drupal version som temat är kombitabelt med.

 

Engine » PHPTemplate

Engine förmodas att vara PHPTemplate som standard och dess uppgift är att upptäcka tema funktioner och sidomallar för beteendet av temat.

 

Testa temat…

Nu har vi bara en fil » temanamn.info men vi kan aktivera temat nu och då kommer Drupal att generera sidan åt oss. Det ser inte så snyggt ut men det fungerar!

 

En koll på Drupals standard klasser

Som du ser gör Drupal en hel del utan att man behöver berätta hur den ska göra det. Om vi kollar på källkoden för sidan kan vi lära oss lite om hur Drupal genererar klasser till element, ta en titt på body elementet:

 

<body class="html front logged-in no-sidebars page-node admin-menu">

Som du ser kan man lätt förstå sig på hur Drupal bestämmer vilka klasser som ska adderas på element, och du kan gå igenom och titta på dom olika klasserna på resten av sidan men vi återkommer till det här senare.

 

HTML dokumentet

HTML dokumentet som vi ska omvandla till ett Drupal tema är en basic HTML5 dokument:

 

<!doctype html>
<html lang="sv-SE">
<head>
	<meta charset="UTF-8" />
	<title>Hem | cr8gr8designs.com</title>
	<meta name="author" content="Daniel Karjanlahti" />
	<link rel="stylesheet" type="text/css" href="style.css" />
</head>
<body>
	<header>
		<h1>cr8gr8designs.com</h1>
		<h2>Lär dig webbutveckling online den <time datetime="30-10-2014">30-10-2014</time></h2>
		<nav>
			<ul>
				<li><a href=”#”>Hem</a></li>
				<li><a href=”#”>Galleri</a></li>
				<li><a href=”#”>Portfolio</a></li>
				<li><a href=”#”>Kontakt</a></li>
			</ul>
		</nav>
	</header>
	<section>
		<header>
			<h1>Heading One</h1>
			<span></span>
		</header>
		<p></p>
	</section>
	<footer>
		<p>Skapad av <a href="mailto:mail@cr8gr8designs.com">Daniel Karjanlahti</a> den <time datetime="22-11-2014">22-11-2014</time><br /> GNU Licence 2014</p>
	</footer>
</body>	
</html>

 

Den är en basic HTML5 sida utan krusiduller, men meningen är att du ska förstå sammanhanget mellan olika delar när du bygger temat.

 

Huvudfiler

 

page.tpl.php

Page.tpl.php är huvudmallen för alla sidor och den som presenterar noder, block, kommentarer, views och andra Drupal byggstenar.

 

Innehåll i page.tpl.php

  • Små PHP snuttar som printar ut variabler:
<?php print $content ?>
  • Basic logik:
<?php if($logged_in): // om användare är inloggad... ?>
<?php endif; ?>
  • Den ska INTE anropa funktioner, för den ska användas för presaentation och innehåller nästan bara HTML med ytterst små snuttar PHP

 

Typer av .tpl.php filer

Det finns 5 basic mallar för olika delar av temat:

  • page.tpl.php » kontrollerar övergripande funktion av sidan
  • block.tpl.php » till för individuella block (byggstenar i Drupal)
  • node.tpl.php » skriver ut alla noder (artiklar osv.) och har två lägen » teaser som visar en del av innehållet och full där hela noden visas.
  • box.tpl.php » bara en omslutande div comments.tpl.php
  • comment.tpl.php » visar kommentar noder

 

Variationer av .tpl.php

Man kan också skapa helt egna varianter av t.ex. node.tpl.php:

  • node-blog.tpl.php
  • node-article.tpl.php
  • node-news.tpl.php

Sedan har en massa andra varianter också:

 

page-front.tpl.php // som då visar framsidan/hemsidan

 

Det finns en massa andra variationer som du kan titta på Drupal.org

 

Vi börjar modifiera page.tpl.php

Okej nu kan vi börja med att modifiera page.tpl.php filen så att den fungerar med Drupal. Skriv in innehållet från HTML dokumentet som jag visade innan i page.tpl.php och så tar vi och fixar till head delen. Skriv in följande mellan head taggarna:

 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="<?php print $language->language; ?>" version="XHTML+RDFa 1.0" dir="<?php print $language->dir; ?>"<?php print $rdf_namespaces; ?>>

 

Sedan har vi title, stilar, skript och en head hook så att man kan komma åt den från andra ställen och fråmst används den av Drupal själv för att lägga till stilar mm.

 

<title><?php print $head_title; ?></title>
<?php print $head; ?>
<?php print $styles; ?>
<?php print $scripts; ?>

 

Nu kommer Drupal att skriva titeln dynamiskt och ladda in standard stilar och skript och dom som angivits i .info filen, och du kan hitta dessa bland en massa andra:

 

<title>cr8gr8designs.com | Webbutveckling online</title>
<style type="text/css" media="all">
@import url("http://drpl7.local:8083/sites/all/themes/cr8gr8designs/css/style.css?nfg4ad");
</style>

 

 

Vi fortsätter med dynamisk innehåll

Det finns en massa variabler som man kan använda sig av och du hittar en lista med dom på Drupal.org. Vidare med h1 & h2 » sidotitel  och slogan:

 

<h1><a href="<?php print $front_page; ?>" title="<?php print t('Hem'); ?>" rel="home"><?php print $site_name; ?></a></h1>
<h2><?php print $site_slogan; ?></h2>

 

Huvudmeny

Ny är det dags för huvudmenyn som ska genereras av Drupal dynamiskt, så vi får ändra en del på koden:

 

<?php if ($main_menu): ?><!-- om menu finns... -->
<nav class="header-menu navigation">
<?php print theme('links', array('links' => $main_menu, 'attributes' => array('class' => array('menu-items'), ), 'heading' => array('text' => t('Huvudmeny'), 'level' => 'h2', 'class' => array('element-invisible'), ), )); ?>
<?php if (!$user->uid) { print '<a href="/user">Login</a>'; } ?><!-- en extra länk för inloggning -->
</nav> <!-- /.header-menu -->
<?php endif; ?>

 

Jag la till en extra länk (i svart) om man är utloggad så dyker det upp en inloggningslänk. Om du laddar om sidan nu så ska den nya menyn fungera som det ska och länka till rätt sida.

Och så har vi sökrutan som finns i en array som kan konfigureras i admin penelen och den ska få plats i header delen av sidan:

 

<?php print render($page['header']); ?>

 

Redigering, hjälp mm. av noder

När man skapar en nod (innehåll) i Drupal så visas ett meddelande om att det lyckades och så finns det flikar där man kan välja att redigera noden, och det är dom sakerna som ska in i huvudinnehållet:

 

<?php if ($page['highlighted']): ?><div id="highlighted"><?php print render($page['highlighted']); ?></div><?php endif; ?>
<?php print render($title_prefix); ?>
<?php if ($title): ?><h1 class="title" id="page-title"><?php print $title; ?></h1><?php endif; ?>
<?php print render($title_suffix); ?>
<?php if ($tabs): ?><div class="tabs"><?php print render($tabs); ?></div><?php endif; ?>
<?php print render($page['help']); ?>
<?php if ($action_links): ?><ul class="action-links"><?php print render($action_links); ?></ul><?php endif; ?>
<?php 
// här kommer själva innehållet
print render($page['content']); 
?>
<?php print $feed_icons; ?>

 

Om du nu går till en “ensam” nod, som en artikel eller sida kommer du att se tre flikar » View, Edit och Devel (om du har Devel modulen aktiverad)

 

Regions

Regions anger platser i temat som man ska kunna lägga Block med länkar, menyer mm. genom att gå till » Administration » Structure » Blocks, och regionerna skrivs in i .info filen. Drupal tillhandahåller fem standard regioner men om man ska lägga till egna kommer dom att skrivas över, så därför skriver vi i dom.

 

Regioner som finns som standard i Drupal 7:

 

regions[header] = Header
regions[highlighted] = Highlighted
regions[help] = Help
regions[content] = Content
regions[sidebar_first] = Left sidebar
regions[sidebar_second] = Right sidebar
regions[footer] = Footer

 

Du hittar en lista med standard variabler för Block inställningar på Drupal.org

Vi ska lägga till stöd för ett gäng regioner i .info filen och ett par egna specialare så att du kan göra liknande modifieringar i framtiden:

 

regions[sidebar_first] = Leftsidebar
regions[sidebar_second] = Right sidebar
regions[content] = Content
regions[header] = Header
regions[footer_left] = Footer Left
regions[footer_right] = Footer Right
regions[highlighted] = Highlighted
regions[help] = Help
regions[page_top] = Page Top
regions[page_bottom] = Page Bottom

 

Vi lägger till dom där två footer regionerna i page.tpl.php mallen:

 

<?php print render($page['footer_left']); ?>
<?php print render($page['footer_right']); ?>

 

Och så dom två sidospalterna på varsin sida om huvudinnehållet (eller där du tycker att det passar att placera dom):

 

<?php if($page['sidebar_first']) { ?>
	<aside class="sidebar left">
		<?php print render($page['sidebar_first']); ?>
	</aside>
<?php } ?>

<?php if($page['sidebar_second']) { ?>
	<aside class="sidebar right">
		<?php print render($page['sidebar_second']); ?>
	</aside>
<?php } ?>

Gruppera app-ikoner i Launchpad

Ibland kan det samlas en massa applikationer och du kanske vill få lite ordning på dom genom att gruppera webbläsare, utvecklingsverktyg mm. så vi ska gruppera app-ikoner i Launchpad idag. Så här kan det se ut:

ScreenShot - Fullt med applikationer i Launchpad
Fullt med applikationer i Launchpad

 

Tänk om du skulle gruppera liknande applikationer så att det ser ut som ”Tillbehör” (Utilities), det kan du!

OS X launchpad icon
OS X launchpad icon

Följ stegen nedanför för att gruppera appikoner i virtuella mappar:

  • Håll ner ALT och flytta en appikon över en annan och håll den där tills det skapas en ram runt den och efter det öppnar den sig, och nu kan du släppa den där:
Screen-Shot-put-app-in-folder
Efter ett tag skapas en ram runt ikonen och den öppnar sig
  •  Gruppera nu tills du är nöjd:
launchpad
Gruppera app-ikoner i Launchpad
  • OS X försöker ge namn för dessa virtuella mappar men du kanske vill ändra namn på dom vilket är enkelt, du öppnar en mapp och klickar på namnet:
Screen-Shot-ändra-namn
Klicka på texten så blir den redigerbar
  •  Nu skriver du bara in det namn du vill ha:
Screen-Shot-ändrat-namn
Skriv in det nya namnet

Så där nu har du grupperat appikonerna i Launchpad!

Slide out Meny med JavaScript

Idag ska vi skapa ett väldigt populär meny-alternativ, nämligen en slide out meny med JavaScript som man gömmer som standard och visar (och gömmer igen) genom att man trycker på en meny-ikon som består av tre streck ☰ [1] . Jag gjorde en likadan meny i en tidigare artikel ”Slide out Meny med bara CSS & HTML” som använde bara CSS, den här gången så använder vi oss av JavaScript istället, för att gömma och visa menyn. 

[1] Meny-ikonen ☰ kan du enkelt hämta från http://copypastecharacter.com som har en massa roliga tecken och symboler som man kan kopiera. 

HTML basen

Till en början får vi skapa själva HTML koden för menyn, och till den så använder jag mig av en enkel oordnad lista med ankare:

<div class="menu-wrapper">
        <label for="toggle" class="menu-icon">☰</label>
	<input type="checkbox" id="toggle" />
         <aside id="sidebar-menu" class="hide">
		<nav class="main-menu">
			<ul>
				<li class="menu-item active"><a href="http://google.com">Google</a></li>
				<li class="menu-item"><a href="http://localhost/~d/labb_cms2/wordpress/wp-login.php">cr8gr8dsgns</a></li>
				<li class="menu-item"><a href="#">DeviantART</a></li>
				<li class="menu-item"><a href="http://facebook.com">Facebook</a></li>
			</ul>
		</nav>
	</aside>
</div><!--  /.menu-wrapper -->

 

 

…Och så CSS koden där vi sätter box-sizing till border-box vilket betyder att när man anger en bredd eller höjd är det med kantlinjer inkluderade:

body {
    box-sizing: border-box;
    -moz-box-sizing: border-box;
    -webkit-box-sizing: border-box;
    font:100 1rem/150% Futura, 'Avenir Next', Avenir, sans-serif;
    width:100%;
    min-height:1000px;
    background-color:rgb(252,252,252);
}
.menu-wrapper {
    position: relative;
}
#sidebar-menu {
    transition: all 0.4s;
    -webkit-transition: all 0.4s;
    position:fixed;
    top:0;
    width: 125px;
    z-index:1;
    height:100%;
    padding:38px 38px 38px 0;
    background:rgb(20,20,20);
}
.menu-item a {
    font:100 1rem/250% Futura, 'Avenir Next', Avenir, sans-serif;
    color:rgba(255,255,255,.9);
    text-decoration:none;
    display:block;
}
.menu-item a:hover {
    color:rgba(255,100,100,.8);
}
.active a {
    color:rgba(255,100,100,.8);
}
.active a:hover {
    color:rgba(255,100,100,.8);
}
input[type="checkbox"] {
    visibility: hidden;
}
.menu-icon {
    text-decoration:none;
    position:fixed;
    top:20px;
    left:200px;
    font-size:2.5rem;
    color:rgb(0,0,0,.9);
}
.menu-icon:hover {
    cursor: pointer;
}<br>

…och för att enkelt kunna ändra beteende på menyn, skapar vi två klasser som dynamiskt läggs till/tas bort:

.hide {
    left: -125px;
}
.show {
    left: 0;
}

 

Onclick event

Nu ska vi lägga till en onclick event på <label> för det är den som ska reprecentera meny-ikonen. Här kommer koden till den:

 <label for="toggle" class="menu-icon" onclick="hideShow()">☰</label>

 

 

JavaScript koden

Nu kommer själva motorn i menyn, nämligen JavaScripten. Vi hämtar menyn med getElementById och kollar med en if sats vilken klass den har för tillfället, och ändrar den i förhållande till det, d.v.s. att om den har klassen hide så byter vi ut den mot show och vice versa:

function hideShow() {
    menu = document.getElementById("sidebar-menu");
    if (menu.className === "show") {
        menu.className = "hide";
    } else {
        menu.className = "show";
    }
}

Slide out Meny med bara CSS & HTML

Artikeln finns somPDF här medlemssidorna

Idag tänkte jag att vi skulle skapa en väldigt populär meny-alternativ, nämligen en slide out meny som man gömmer som standard och visar (och gömmer igen) genom att man trycker på en meny-ikon som består av tre streck ☰ [1] .

[1] Meny-ikonen ☰ kan du enkelt hämta från http://copypastecharacter.com som har en massa roliga tecken och symboler som man kan kopiera. 

Så här ska det se ut gömd och…
Så här ska det se ut gömd och…
Skärmavbild-meny-utfälld
så här, när den kommer fram.

HTML koden

Vi börjar med att skapa en sidospalt som ska innehålla själva menyn, och vi placerar den antingen efter alla andra element, precis innan avslutande </body> taggen eller innan alla andra element precis efter första <body> taggen.

Här kommer koden för sidospalten:

<!-- HTMl koden -->             
<aside class="sidebar-menu">
	<nav class="main-menu">
		<ul>
			<li class="menu-item active"><a href="#">Hem</a></li>
			<li class="menu-item"><a href="#">Portfolio</a></li>
			<li class="menu-item"><a href="#">Galleri</a></li>
			<li class="menu-item"><a href="#">Kontakt</a></li>
		</ul>
	</nav>
</aside>

 

CSS

Jag brukar alltid återställa alla element och sätta alla HTML5 element till block-element för äldre webbläsare, plus att jag använder box-sizing för att enklare räkna ut alla mått för då räknas marginaler, kantlinjer och padding i bredd / höjd regler:

/* jag använder * som är en wildcard, och gäller för alla element */

* {
	box-sizing: border-box;
    	-moz-box-sizing: border-box;
    	-webkit-box-sizing: border-box;
    	margin: 0;
    	padding: 0;
    	border: 0;
    	font-size: 100%;
    	font: inherit;
    	vertical-align: baseline;
}

/* HTML5 display-roll för äldre webbläsare */
article, aside, details, figcaption, figure, 
footer, header, hgroup, menu, nav, section {
	display: block;
}

Nu ska vi se till att sidospalts-meny tar upp fulla höjden och placera den längst till vänster med fixerad position, plus att vi säter z-index till ett positiv tal så att den hamnar ovanför allt innehåll och kommer då inte att störa flödet när den pressas in från sidan:

body {
	width:100%;
	min-height:1000px;
	background-color:rgb(250,250,250);
}
.sidebar-menu {
	position:fixed;
	top:0;
	left:0px; /**
			* vänster position ändrar vi senare till ett negativt tal, 
			* för att gömma den, men nu vill vi se den 
			*/
	width:120px;
	height:100%;
	padding:38px 38px 38px 20px;
	background-color:rgb(20,20,20); /* nice mörk bakgrund */
}

Nu ska vi styla ankar-elementen så att dom blir lite snyggare genom att ange font, färg och ta bort text-dekoration:

.menu-item a {
	font:100 1rem/250% Futura, 'Avenir Next', Avenir, sans-serif;
	color:rgba(255,255,255,.9);
	text-decoration:none;
}
.active a {
	color:rgba(255,100,100,.8);
}
/* och så stilar för :hover läge */
.menu-item a:hover {
	color:rgba(255,100,100,.8);
}
.active a:hover {
	color:rgba(255,100,100,.8);
}
Skärmavbild-meny-halvvägs
Och det här har vi åstadkommit hittills,
och jag tycker att det börjar arta sig visuellt.

 

”Knappen”

Okej, vi behöver ha en funktion för att gömma / visa menyn, och för att åstadkomma det behövs en ”knapp” som man trycker på, och för det har vi ett par alternativ; input[type=”checkbox”] eller input[type=”radio”], men jag tänkte använda input[type=”checkbox”] varianten för det här exemplet, och så behövs en label som är knuten till den så att när man klickar på label texten så reagerar chockboxen, så label måste ha en for attribut som länkar till checkboxen. Vi skriver in dom och omger allt med en <div> som har klassen menu-wrapper:

<div class="menu-wrapper">
	<label for="toggle" class="menu-icon">☰</label>
	<input type="checkbox" id="toggle" name="" value="" />
	<aside class="sidebar-menu">
		<nav class="main-menu">
			<ul>
				<li class="menu-item active"><a href="#">Hem</a></li>
				<li class="menu-item"><a href="#">Portfolio</a></li>
				<li class="menu-item"><a href="#">Galleri</a></li>
				<li class="menu-item"><a href="#">Kontakt</a></li>
			</ul>
		</nav>
	</aside>
</div><!--  /.menu-wrapper -->

 

Växlingsfunktionen

Okej, nu kommer det roliga! Vi börjar med att placera label som blir själva menu-ikonen, och ändrar på muspekaren när man hovrar över den, och till sist ska vi gömma checkboxen:

.menu-icon {
	text-decoration:none;
	position:fixed;
	top:20px;
	left:200px;
	font-size:2.5rem;
	color:rgb(0,0,0,.9);
}
.menu-icon:hover {
    cursor: pointer;
}
#toggle {
	/* göm checkbox */
	display: none;	
}
Skärmavbild-meny-ikon
Och så här ser vår menyikon ut

…och så det magiska, nämligen att när checkbox är ikryssad, så gäller position vänster 0 för dess syskon som är sidebar-menu, och vi åstadkommer det genom att sätta en plus tecken efter checkbox när den har attributet checked:

#toggle:checked + .sidebar-menu {
	left:0;
}

Till sist byter vi ut värdet för left i sidebar-menu till ett negativt tal som är minst dess bredd:

.sidebar-menu {
	left:-120px;
}

 

Och här kommer hela koden:

<!doctype html>
<html lang="sv-SE">
<head>
	<meta charset="UTF-8" />
	<title>Slide-out Meny | cr8gr8designs.com</title>
<style>
* {
    box-sizing: border-box;
    -moz-box-sizing: border-box;
    -webkit-box-sizing: border-box;
    margin: 0;
    padding: 0;
    border: 0;
    font-size: 100%;
    font: inherit;
    vertical-align: baseline;
}

/* HTML5 display-role reset for older browsers */
article, aside, details, figcaption, figure, 
footer, header, hgroup, menu, nav, section {
    display: block;
}

body {
	font:100 1rem/150% Futura, 'Avenir Next', Avenir, sans-serif;
	width:100%;
	min-height:1000px;
	background-color:rgb(252,252,252);
}
.sidebar-menu {
    	transition: all 0.4s;
    	-webkit-transition: all 0.4s;
	position:fixed;
	top:0;
	left:-120px;
	z-index:1;
	width:120px;
	height:100%;
	padding:38px 38px 38px 20px;
	background:rgb(20,20,20);
}
.menu-item a {
	font:100 1rem/250% Futura, 'Avenir Next', Avenir, sans-serif;
	color:rgba(255,255,255,.9);
	text-decoration:none;
	display:block;
}
.menu-item a:hover {
	color:rgba(255,100,100,.8);
}
.active a {
	color:rgba(255,100,100,.8);
}
.active a:hover {
	color:rgba(255,100,100,.8);
}
.menu-icon {
	text-decoration:none;
	position:fixed;
	top:20px;
	left:200px;
	font-size:2.5rem;
	color:rgb(0,0,0,.9);
}
.menu-icon:hover {
    cursor: pointer;
}
#toggle {
	display: none;  /*hide */
	
}
#toggle:checked + .sidebar-menu {
	left:0;
}
</style>
</head>
<body>
	<div class="menu-wrapper">
		<label for="toggle" class="menu-icon">☰</label>
		<input type="checkbox" id="toggle" />
		<aside class="sidebar-menu">
			<nav class="main-menu">
				<ul>
					<li class="menu-item active"><a href="#">Hem</a></li>
					<li class="menu-item"><a href="#">Portfolio</a></li>
					<li class="menu-item"><a href="#">Galleri</a></li>
					<li class="menu-item"><a href="#">Kontakt</a></li>
				</ul>
			</nav>
		</aside>
	</div><!--  /.menu-wrapper -->
</body>
</html>

Och det var allt för den här gången, och till nästa, koda smart ; )

Vänligen, Daniel Karjanlahti på cr8gr8designs.com

Menyer i WordPress

Att skapa menyer i WordPress kan vara rätt krångligt, och det finns ett antal sätt att skapa en, jag tänkte gå igenom ett par av mina favoriter. Vi börjar med att registrera menyer för olika platser, för du har väl tänkt på att man kan ha flera menyer i vissa teman? Så detta ska in i functions.php:!

// Registrera Menyer För Temat
add_action( 'init', 'register_my_menus' );

function register_my_menus() { 
	register_nav_menus(
		array(
			'header-menu' => __( 'Header Menu' ), 
			'sidebar-menu' => __( 'Sidebar Menu' ), 
			'footer-menu' => __( 'Footer Menu' )
		)
	);
}

 

wp_nav_menu

När du har lagt till koden på din functions.php, kommer du att märka att du kan hantera menypositioner. Du kan nu hitta dina nya menyer under:

http://din_sida/wp­-admin/nav-­menus.php

I funktionen wp_nav_menu som har 15 parametrar totalt att välja mellan, och här ser vi standard värdena för dom:

<?php
$defaults = array(
	'theme_location'  => '', /* header-menu, sidebar-menu och footer-menu */
	'menu'            => '',
	'container'       => 'nav', /* HTML-element som omgärdar listan */
	'container_class' => '', /* klass för HTML-element som omgärdar listan */
	'container_id'    => '', /* ID för HTML-element som omgärdar listan */
	'menu_class'      => 'menu',
	'menu_id'         => '',
	'echo'            => true,
	'fallback_cb'     => 'wp_page_menu',
	'before'          => '',
	'after'           => '',
	'link_before'     => '',
	'link_after'      => '',
	'items_wrap'      => '<ul id="%1$s" class="%2$s">%3$s</ul>',
	'depth'           => 0,
	'walker'          => ''
);
wp_nav_menu($defaults);
?>

 

Och dessa har alla en betydelse så klart:

  • $theme_location – Menyn som du vill visa (som registrerades i functions.php).
  • $menu – Kalla en meny med id, namn eller slug.
  • $container – Vad du vill omgärda ul elementet med, som t.ex. div eller nav.
  • $container_class – Klassen som läggs på $container.
  • $container_id – ID som läggs på $container.
  • $menu_class – Klassen som läggs på ul elementet i menyn.
  • $menu_id – The id to be applied to the ul element of the menu.
  • $echo – Om man ska echo menyn eller return det.
  • $fallback_cb – Om ingen meny finns, vilken fallback funktion som ska användas.
  • $before – Text innan ankar länken.
  • $after – Text efter ankar länken.
  • $link_before – Text innan länk-texten.
  • $link_after – Text efter länk-texten.
  • $depth – Hur många nivåer av meny hierarkin som ska visas.
  • $walker – Anpassad objekt.

Som tur är behöver man inte skriva in alla. För att ange vilken meny man anropar ska du använda $theme_location parametern, som syftar på det namn du registrerat i functions.php.

Till exempel, om vi använder exemplet från början (i functions.php), kan du nu lägga till följande kod till dina mallar för att visa huvudnavigering (header-menu):

// header-php
<?php wp_nav_menu(array('theme_location' => 'header-menu')); ?>

// sidebar.php
<?php wp_nav_menu(array('theme_location' => 'sidebar-menu')); ?>

// och till sist footer.php
<?php wp_nav_menu(array('theme_location' => 'footer-menu')); ?>

 

Som du ser har jag bara en parameter i funktionen, men vi kan enkelt lägga till flera, och jag tänkte att vi lägger till nav som ett omgärdande element och en klass main-menu till den:

// header.php
<?php 
wp_nav_menu(
	array(
		'theme_location' => 'header-menu',
		'container' => 'nav',
		'container_class' => 'main-menu'
	)
); 
?>

 

Klasserna ”current_page_item” & ”current-menu-item”

WordPress skapar automatisk ett antal klasser för navigationen, och om du kollar på källkoden för menyn vi precis skapade så hittar du liknande HTML-kod:

<nav class="header-menu">
	<ul id="menu-header-menu" class="menu">
		<li id="menu-item-63" class="menu-item menu-item-type-custom menu-item-object-custom current-menu-item current_page_item menu-item-home menu-item-63">
			<a href="http://localhost/wp/">Hemsida</a>
		</li>
		<li id="menu-item-60" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-60">
			<a href="http://localhost/wp/galleri">Galleri</a>
		</li>
	</ul>
</nav>

 

Som du ser blir det en massa klasser men två viktigaste är; ”current_page_item” och ”current-menu-item”, för med hjälp av dom kan vi styla menyknappen som är aktiv (sidan man är på), och ”menu-item-home” är specik för hemsidan.”menu-item” är en generell klass som kommer att skapas för varje <li> element, i alla menyer och resten är unika i installationen. Här är en lista på  standard klasser som WordPress skapar:

current_page_item 		– Stylar den aktuella sidan. 
current­-cat 			– Stylar den aktuella kategorin. 
menu­-item 			– Stylar alla andra menyalternativ. 
menu­-item­-type­-taxonomy 	– Stylar kategorilänkar. 
menu­-item­-type­-post_type 	– Stylar sidolänkar. 
menu­-item­-type­-custom 	        – Stylar anpassade objekt. 
menu­-item­-home 		        – Stylar hemsidan länken.

Man kan enkelt lägga till en egen klass för en enskild länk, genom att klicka på ”Panelinställningar” högst upp på sidan Menyer, då kommer en rullgardinsmeny att sänkas ner. Därifrån hittar du ett alternativ för att visa ”CSS Klasser” under rubriken ”Visa avancerade menyalternativ”:

Bild på "Panelinställningar" på sidan "Menyer"
”Panelinställningar” på sidan ”Menyer”

Nu kan du lägga till en klass under menyinställningar:

Bild på Admin Panelen » Menyer » CSS Klass
Admin Panelen » Menyer » CSS Klass