PHP Namespace

Idag tänkte jag gå igenom PHP Namespace funktionaliteten som kom med PHP 5.3. Om du arbetat med C# eller Java så känner du till konceptet namespace, men för andra icke invigda så är det helt enkelt ett sätt att undvika namn-kollisioner genom att skapa en sorts mapphierarki för namnen, för du kan t.ex. ha exempel.php i två olika mappar men du kan inte ha dom i samma.

Okej, vi tar ett exempel:

namespace A;

class B {
   // 
   function doit() {
      return __NAMESPACE__;
   }
}

\A\doit();

 

 

Installera Composer på OS X

Composer är ett plattformsberoende manager för PHP-bibliotek, den installera paket som man behöver i ett specifikt projekt med ett enda kommando. I denna artikel kommer jag att förklara hur man ska Installera Composer på OS X, och sedan lägga till en alias, så den kan användas från överallt på datorn utan att behöva skriva in den fulla sökvägen vid varje kommando.

 

Installation

Det första steget är så klart att ladda ner Composer, som då samtidigt kommer att skapa en PHP Arkiv (phar) som heter composer.phar.

Öppna terminal appen, och kör följande kommando:

curl -SS https://getcomposer.org/installer | php

 

Installations fel

I vissa fall kan du få följande felmeddelande:

Some settings on your machine make Composer unable to work properly.
Make sure that you fix the issues listed below and run this script again:

The detect_unicode setting must be disabled.
Add the following to the end of your `php.ini`:
detect_unicode = Off

A php.ini file does not exist. You will have to create one.
If you can not modify the ini file, you can also run `php -d option=value` to modify ini values on the fly. You can use -d multiple times.

För OS X 10.8, bör php.ini filen ligga i /private/etc/. Om du inte redan har ett, kan du kopiera den förvalda:

sudo cp /private/etc/php.ini.default php.ini

Därefter, redigera filen genom att lägg till följande:

detect_unicode = Off

Spara filen och kör curl kommandot som installerar Composer ovan.

 

Köra Composer

Den resulterande filen kommer att kallas composer.phar, ett PHP Arkiv som kan exekveras direkt via PHP. Men vi vill att Composer ska vara tillgänglig globalt, så att vi kommer åt den genom att endast skriva composer istället för hela sökvägen. För att göra detta, flytta composer.phar till /usr/bin/ och skapa ett alias för den:

sudo mv composer.phar /usr/bin/
nano ~/.bash_profile

Lägg detta till din .bash_profile. Som kan vara tom eller inte ens finnas, så det är bara att skapa en:

alias composer="php /usr/bin/composer.phar"

Starta om din terminal nu kommer du att kunna komma åt Composer helt enkelt genom att skriva composer i Terminalen. Då får du följande output:

Composer output i Terminal.app
Composer output i Terminal.app

För att installera Composer på Windows kan man bara ladda ner installationsprogrammet Composer-Setup.exe och köra.

 

Så där, det var det. Hoppas att du lärt dig något och till nästa gång koda smart 😉

 

Dynamisk Webbsida Med PHP

Idag ska vi skapa en dynamisk webbsida med PHP och du ska redan kunna en del PHP, HTML och CSS för att få ut det mesta av den här guiden.

 

PHP

PHP står för PHP: Hypertext Preprocessor, och är ett av dom populäraste scriptspråk som körs på webbservrar för att driva webbsidor med dynamiskt innehåll (d.v.s. innehåll som genereras från t.ex. en databas, validering av formulärdata mm.) PHP är ett scriptspråk som tolkas av en interpretator som heter Zend Engine. Man använder PHP tillsammans med HTML och SQL (plus en del andra tekniker) för att generera innehåll.

 

Syntax

Man skriver PHP antingen i egna filer eller så blandar man med HTML. Koden skriver man mellan PHP avgränsare. Skriv in följande i en fil och spara den med filändelsen .php i din webbrot [1]:

<?php
// Detta är en kommentar på en rad, och skrivs inte ut

/*
Detta är också en kommentar, 
men på flera rader
*/

echo 'echo är en så kallad språk konstrukt som skriver ut strängar i webbläsaren'; 

# Detta är också en kommentar på en rad
?>

[1] Webbroten » om du kör WAMP är det C:/WAMP/www/ och för MAMP är det /Applications/MAMP/htdocs/ och för en LAMP (Linux Apache MySQL PHP) installation är det /var/www/html.

Kommentarer syns inte i utskrift och kan skrivas på tre sätt:

  1. på en rad, med hashtag #
  2. på en rad, med dubbla snedstreck //
  3. eller på flera rader, mellan /* och */.

Strängar skrivs mellan enkla eller dubbla citationstecken. Men enkla citationstecken bearbetas snabbare, är säkrare och är mindre benägna att orsaka programmeringsfel i PHP. Det finns dock undantag, som t.ex. om man vill få med en PHP-variabel i utskriften använder man dubbla för att slippa man konkatenera den till strängen (vilket skulle bearbetas saktare), utan kan istälet skriva in den direkt i strängen så här:

$someString = 'sträng';
// om vi echo ut en sträng tillsammans med variabeln använder vi dubbla citationstecken
echo "En PHP-variabel i en $someString";

 

En liten sida

Jag tänkte vi skulle skapa en liten sida och lära oss lite på vägen. Börja med att skapa en PHP-fil och skriva in följande och spara som index.php:

<!doctype html>
<html lang="sv-SE">
<head>
	<meta charset="UTF-8" />
	<title>Dynamisk Webbsida Med PHP | cr8gr8designs.com</title>
        <link rel="stylesheet" href="style.css" />
</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 -->
        <section class="main-section">
                <!-- PHP kod ska in här senare -->
        </section>
</body>
</html>

…och en CSS-stilmall, med den här koden:

* {
    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:block reset för äldre webbläsare */
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;
}

Nu har vi en startsida som vi kan arbeta med. För att göra sidan dynamisk börjar vi med att modifiera menyn genom att modifiera href attributen så här:

<li class="menu-item active"><a href="?page=hem">Hem</a></li>
<li class="menu-item"><a href="?page=portfolio">Portfolio</a></li>
<li class="menu-item"><a href="?page=galleri">Galleri</a></li>
<li class="menu-item"><a href="?page=kontakt">Kontakt</a></li>

Här lägger vi till en variabel page som ändras beroende på vilken länk man klickar på. Testa att klicka på länkarna och kolla i adressfältet, där du bör se följande:

page variabeln syns i adressfältet när man klickar på menylänkarna
page variabeln syns i adressfältet när man klickar på menylänkarna

Det här kan vi använda oss av eftersom det går att komma åt page variabeln med PHP superglobaln $_GET. Vi kan nu servera innehåll, beroende på vilket värde page variablen har. Vi skapar nya filer i en ny mapp som vi ger namnet templates, där vi skapar fyra nya filer som ska heta:

  1. hem.php
  2. portfolio.php
  3. galleri.php
  4. kontakt.php

I dessa kan vi nu skriva in vad vi vill visa. Du ska få göra det själv då det inte har någon betydelse för guiden, men jag kan visa ett exempel på en mallsida/template:

<div>
    <h1>Välkommen till cr8gr8designs.com</h1>
    <span>Skapad av <a href="mailto:mail@cr8gr8designs.com">Daniel K</a></span>
    <p>
        Front-end och back-end är begrepp som används inom informationsteknik för att beteckna den bearbetning som sker av eller nära användaren (användargränssnittsorienterad bearbetning – front-end) och själva basbearbetningen (ofta på servernivå – back-end).
        I modern datateknik associeras ofta front-end med webbaserade mjukvarumoduler baserade på HTML, CSS och JavaScript, där utvecklarna av dessa delar kallas webbutvecklare eller webbdesigners.
        Sättet att bygga uppdatorsystem enligt front-end och back-end kallas också two-tier architecture. (källa <a href="http://sv.wikipedia.org/wiki/Front-end_och_back-end">Wikipedia</a>)
    </p>
</div>

Vi behöver inte deklarera <doctype html>, <head> och <body> m.fl. då vi redan har grunden i index.php där denna del av sida ska visas. Så, nu skapar vi en sträng som ändras beroende på vilket värde page har. Skriv in följande mellan <section> taggarna:

<section class="main-section">
<?php
// vi deklarerar en PHP-variabel som får värdet från page
// i PHP behöver man inte ange specifik typ för variabler -
// för det sköter PHP automatiskt
$page = $_GET['page'];

// vi skapar en sträng med sökvägen till template fil,
// som ändras beroende på page variabeln, lägg märke till att man konkatenerar -
// strängar med en punkt istället för + som är en annan operator -
// du kan kolla på all här http://php.net/manual/en/language.operators.php
$filename = "templates/" . $page . ".php";

// om filen finns
if (file_exists($filename)) {
    // renderar vi den
    include_once $filename;
} else {
    // annars har page variabeln inte ett värde är
    // och då är användaren på hemsidan eftersom ingen länk ännu klickats
    include_once 'templates/hem.php';
}
?>

Nu har vi skapat en enkel template system som serverar sida beroende på vilken sida användaren är på.

 

Separera Logik & Presentation

Det är dock inte god kodningsstandard att blanda logik och presentation, utan man ska försöka till så stor del som möjligt separera dom. Därför ska vi skapa en ny mapp som heter functions, och däri en PHP-fil som heter likadant:

Mappstruktur
Mappstruktur

Vi flyttar PHP koden från index.php till en funktion i functions.php:

<?php

/**
 * Renderar sidoinnehåll
 * @param string $page
 */
function renderPage($page) {
    $filename = "templates/" . $page . ".php";
    
    // om page har ett värde och filen finns
    if (file_exists($filename)) {
        // renderar vi sidan
        include_once $filename;
    } else {
        // annars visas hemsidan
        include_once 'templates/hem.php';
    }
}

…och så skriver vi inkluderingen av function.php och deklarationen av $page variabeln på toppen av sidan:

<?php
require_once 'functions/functions.php';
$page = $_GET['page']; ?>
<!doctype html>
<!-- och så vidare -->

Okej, nu kan du använda funktionen genom att anropa den, så byt ut all PHP-kod mellan <section> taggarna i index.php mot det här:

<?php
renderPage($page); 
?>

 

Dynamisk Meny

Jag har även satt ihop en funktion som skapar en dynamisk meny. Den använder sig av en kort if sats, och används på det här sättet:

// detta är inte riktig kod utan visar bara hur det fungerar
(villkor ? sant : falskt);

Där villkor kan vara vilken jämförelse  som helst, t.ex. a === b och om det är sant gäller sant och om det är falskt så gäller den sista som här är ordet falskt. Ett praktiskt exempel med båda if-satserna:

if(a === b) {
   echo $c;
}else {
   echo $a + $b;
}

// samma villkorliga sats med den korta varianten

echo ($a === $b ? $c : $a + $b);

Här kommer koden till createMenu() funktionen:

/**
 * Skapar en dynamisk menu som lägger till klassen active på aktiv länk
 * @param array $links -> array() med menylänkar
 * @param type $active -> $_GET['page']
 */
function createMenu($links, $active) {
    // initiera sträng som ska innehålla menyn
    $menu = '<ul>';

    // en foreach loop skapar menyn
    foreach ($links as $link) {
        $menu .= '<li class="menu-item';
        // ange klass för aktiv länk, eller ( || ) om $_GET['page'] inte har ett värde än så är man på hemsidan
        $menu .= ($active === $link || ($link === 'hem' && $active === NULL) ? ' active' : '');
        $menu .= '"><a href="?page=' . $link . '">' . ucfirst($link) . '</a></li>';
    }
    echo $menu . '</ul>';
}

…som används så här:

<nav class="main-menu">
    <?php
    // anropa funktionen med en array av dom länkar man vill ha 
    // och $page variabeln som vi deklarerade på toppen av sidan
    createMenu(array('hem', 'galleri', 'portfolio', 'kontakt'), $page);
    ?>
</nav>

Okej, det var allt för den här gången, och till nästa gång koda smart 😉

Välj inte Payson!!!

Jag gjorde en transaktion med Payson vilket visade sig bli ett riktigt djävla fiasko!

Till att börja med låste dom kontot på morgonen efter att jag valde att flytta över pengarna till mitt bankkonto. Sedan försökte jag få tag på dom varje dag men dom hörde inte av sig. Först ville dom ha ett personbevis för bankärenden, vilket jag skickade in. Sedan skulle dom ha ett köpekvitto där jag signerat och kollat köparens ID-kort och sedan fått dennes underskrift. Detta hade jag inte gjort. Så då väljer dom att se det som ett bedrägeri och makulerar transaktionen.

Dom ber mig kontakta polisen så att jag möjligen ska kunna få tillbaka varan.

Nä, fy fan vad arg jag blir när dom hjälper till att fullfölja ett bedrägeri.

Välj inte Payson!!!

Säker Inloggning med LightOpenID

LightOpenID är ett script som låter en användare identifiera sig genom sitt Google konto (plus ett gäng andra, inklusive OpenID), och vi kommet att jobba med en variant som används tillsammans med PHP (finns för andra språk också). Du kan ladda ner den senaste versionen härifrån. Det går att logga in med flera olika tjänster, som;  är ett väldigt säkert alternativ.

Ett annat alternativ för PHP är ett projektet som använder LightOpenID; HybridAuth vilken använder sig av sociala inloggningar med; OpenID, Facebook, Twitter, LinkedIn, Google, Yahoo, Windows Live, Foursquare och AOL och många fler. Du kan hitta en lista över dom i dokumentationen.

Användaren kommer att refereras till som » A

 

Vi börjar med att skriva in följande i huvudmenyn:

// skriv in det här i din huvudmeny
if (!$_SESSION['email']) {
    // om A inte loggat in än, visa "Logga in" länk
    echo '<li><a href="login.php">Logga in</a></li>';
} else {
    // om A har loggat in visas logga ut i menyn
    echo '<li><a href="logout.php">Logga ut</a></li>';
}

…och nästa steg blir att sätta in följande i din login.php:

// login.php
// skapa en ny instans av LightOpenID, med länk till din webb-rot
$openId = new LightOpenID('http://localhost/~dok/login_google/');

// vi använder oss av Google:s inloggning
// den här adressen hämtas till menyn lite längre ner på sidan
$openId->identity = 'https://google.com/accounts/oB/id';

// här specifierar vi vad vi vill veta => förnamn, email och land 
$openId->required = array(
'namePerson/first',
'contact/email',
'contact/country/home'
);

// och så anger vi en return URL som A ska skickas till efteråt
$openId->returnUrl = 'account.php';
?>

<h1>Logga in på sidan</h1>

<!-- och en inloggningslänk > Länk till Google login -->
<a href="<?php $openId->authUrl() ?>">Logga in med Google</a>

<!-- och en vanlig inloggningsformulär -->
<form action="login.php" method="POST">
    <label for="username">Användarnamn:</label><br />
    <input type="text" name="username" /><br />
    <label for="pass">Lösenord</label><br />
    <input type="password" name="pass" /><br />
    <input type="submit" value="Logga in" />
</form>

…och efter att A har klickat på verifiera med Google och verifierat att A låter oss använda A:s email och namn, skickas A till account.php:

// account.php
require_once 'includes/openid.php';

$openId = new LightOpenID('http://localhost/~dok/login_google/');

if ($openId->mode) {
    if ($openId->mode == 'cancel') {
        echo 'Error: användare avbröt inloggning';
    }  elseif ($openId->validate()) {
        // hämta alla attribut för A som vi fick från Google
        $data = $openId->getAttributes();
        $email = $data['contact/email'];
        $fist = $data['namePerson/first'];
        $homeCountry = $data['contact/country/home'];
        
        // sätt attributen till session variabler
        $_SESSION['email'] = $email;
        $_SESSION['firstname'] = $fist;
        $_SESSION['home'] = $homeCountry;

        // skicka A tillbaka till hemsidan
        header('Location: http://localhost/~dok/login_register/');
    }  else {
        echo 'Error: Användare har inte loggat in';
    }
}  else {
    echo 'Error: Gå till hemsidan för att logga in';
}

…nu skickas A till index.php, och där kollar vi om A loggat in och visar lämplig länk i menyn:

if (!$_SESSION['email']) {
    // om användaren avbröt verifiering visas Logga in
    echo '<li><a href="' . $openId->authUrl() . '">Logga in</a></li>';
} else {
    // logga ut länk visas nu istället
    echo '<li><a href="login.php">Logga ut</a></li>';
}

…och i logout.php ska följande in:

// skapa en session så vi kommer åt alla sessions
session_start();

// "förstör" alla sessions
session_destroy();

// skicka tillbaka till hemsidan
header('Location: http://localhost/~dok/login_register/');

Så där nu ska du kunna komma igång med LightOpenID. Och till nästa gång, koda smart 😉

 

Webbshop med PayPal

Ansvarsfriskrivning – Jag kan tyvärr inte garantera att den här artikeln resulterar i en felfri och säker applikation, och det är därför ditt ansvar att kontrollera din kod mot dokumentationen.

I den här artikeln ska vi skapa en – webbshop med PayPal och applikationen kommer att baseras på Classic API. Som du kanske såg i förra avsnittet av den här serien – Skapa Din Egen Nätbutik, så finns det tre steg i en transaktion på nätet:

  1. Kundvagn > ska samla in information om köpet, som kortnummer, adress, namn mm.
  2. Betalningsgateway > krypterar informationen och skickar den till säljarkonto
  3. Säljarkonto > processar informationen och sätter in pengarna på kontot

Vi kommer att använda oss av PayPal:s säljarkonto i den här artikeln.

 

Utvecklingsprocess

Utvecklingsprocessen för en applikation som använder PayPal:s API, har följande steg:

  1. Registrera dig som PayPal utvecklare.
  2. Integrera PayPal-funktionalitet till din webbplats och eventuella mobila applikationer.
  3. Testa dina PayPal transaktionsrutiner i PayPal:s Sandbox.
  4. Gå live med applikationen.
  5. Underhålla och uppgradera applikationen.

 

 

Skapa Utvecklar-konto

Så, till att börja med behöver du skapa ett utvecklar-konto hos PayPal, och du kan göra det här. Där behöver du sedan skapa autentiseringsuppgifter, vilket du kan se hur du ska göra här. Det finns två typer av autentiseringsuppgifter:

  • Signature API autentiseringsuppgifter
  • Certificate API autentiseringsuppgifter

Båda kan användas men PayPal rekommenderar Certificate av säkerhetsskäl. Båda varianterna innehåller tre autentiserings-värden:

  • API Användarnamn
  • API Lösenord
  • Certifikat

Det är dessa som skickas tillsammans med anrop till PayPal API.

Tänk på! Du måste ha ett PayPal Business-konto för att göra anrop till PayPal:s live servrar.

 

Olika Betalningsalternativ

PayPal har ett antal olika betalningsalternativ och det gäller att välja den som passar bäst för just din sida. Men detta kan vara minst sagt förvirrande, då det finns så många alternativ.

 

  • Express Checkout – Med den främsta PayPal tjänsten: Express Checkout kan du få betalningar utan att ha ett konto och utan att behöva fylla speciella kriterier förutom att verifiera ditt PayPal konto (antingen via ett bankkonto eller ett kreditkort). Tidigare kunde man endast ta Express Checkout betalningar från registrerade PayPal-användare, men PayPal har lagt till en kreditkorts alternativ för icke-PayPal-användare, vilket gör denna tjänst tillgänglig för praktiskt taget vem som helst som har ett av dom större kreditkorten (VISA, MasterCard, osv.)
    • Tänk på: Express Checkout processen sker på PayPals plattform och kan därför aldrig bli helt integrerade i din webbplats användargränssnitt.
  • Direct Checkout – Direktbetalnings metoden gör det möjligt att ta emot kreditkortsbetalningar direkt via ett API-anrop. Detta gör att du kan genomföra hela betalningsprocessen på din webbplats, vilket möjliggör en mer komplett shoppingupplevelse för kunderna.
  • Recurring Payments – Detta gör att du kan ställa in ett återkommande transaktion (dvs. en abonnemangs betalning).
  • Mass Payments – Denna metod gör att man kan föra över pengar till flera konton på samma gång.
  • Adaptive Payments – Här är ett annat API för att skicka pengar till flera mottagare, med vissa skillnader från Massbetalnings API:n.

Listan är inte helt komplett, men den innehåller dom populäraste alternativen (se dokumentationen för fler produkter).

 

 

Att Göra API Anrop

PayPal stödjer två huvudsakliga format över HTTP, nämligen: NVP och SOAP. NVP står för ”Name, Value Pair”, och SOAP står för ”Simple Object Access Protocol”. Jag kommer att använda mig av NVP, eftersom SOAP trots sitt namn har ett relativt komplex syntax.

Var och en a dessav API-metoder har olika parametrar, men de båda delar på vissa grundläggande parametrar, som används för att identifiera API kontot och underteckna transaktionen.

Dessa innefattar:

  • USER Din PayPal API användarnamn.
  • PWD Din PayPal API lösenord.
  • VERSION Versions nummer för NVP API service; 95.0 (som är den senaste vid skrivande stund).
  • SIGNATURE Din PayPal API signatur sträng. Denna parameter är valfri om man använder ett certifikat för autentisering.
  • Den sista parameter som krävs är METHOD, vilken deklarerar den API metod vi anropar.

 

Klass för anrop

Anrop görs över HTTPS. Vi använder cURL för att bygga förfrågan, och kapslar in hela processen i en klass:

<?php

class Paypal {
    /**
     * Sista error meddelande(n)
     * @var array
     */
    protected $_errors = array();

    /**
     * API autentiseringsuppgifter
     * Använd korrekt autentiseringsuppgifter (Live / Sandbox)
     * @var array
     */
    protected $_credentials = array(
        'USER' => 'seller_1227648999_cr8gr8designs.com',
        'PWD' => '1297608792',
        'SIGNATURE' => 'A3g66.FS11HYAf1mkHkkl3BDopE3kN.ddRE1wMrInvUEqO3UaLOvity47p',
    );

    /**
     * API endpoint
     * Live - https://api-3t.paypal.com/nvp
     * Sandbox - https://api-3t.sandbox.paypal.com/nvp
     * @var string
     */
    protected $_endPoint = 'https://api-3t.sandbox.paypal.com/nvp';

    /**
     * API Version * @var string */
    protected $_version = '74.0';

    /**
     * Skapar API förfrågan
     * @param string $method sträng för API metod som ska anropas
     * @param array $params Ytterligare anrops parametrar
     * @return array / boolean Svars array / boolean false vid misslyckande */
    public function request($method, $params = array()) {
        $this->_errors = array();
        if (empty($method)) { // Kolla så att API metod inte är tom
            $this->_errors = array('API metod fattas');
            return false;
        }
        // Våra anrops parametrar
        $requestParams = array(
            'METHOD' => $method,
            'VERSION' => $this->_version
                ) + $this->_credentials;
        // Bygg NVP sträng
        $request = http_build_query($requestParams + $params);

        //cURL inställningar
        $curlOptions = array(
            CURLOPT_URL => $this->_endPoint,
            CURLOPT_VERBOSE => 1,
            CURLOPT_SSL_VERIFYPEER => true,
            CURLOPT_SSL_VERIFYHOST => 2,
            CURLOPT_CAINFO => dirname(__FILE__) . '/cacert.pem',  //CA cert fil 
            CURLOPT_RETURNTRANSFER => 1,
            CURLOPT_POST => 1,
            CURLOPT_POSTFIELDS => $request
        );
        $ch = curl_init();
        curl_setopt_array($ch, $curlOptions);
        // Skicka förfrågan - behåll API respons
        $response = curl_exec($ch);
        // Kolla efter cURL error
        if (curl_errno($ch)) {
            $this->_errors = curl_error($ch);
            curl_close($ch);
            return false;
            //Hantera fel
        } else {
            curl_close($ch);
            $responseArray = array();
            parse_str($response, $responseArray);
            // Break the NVP string to an array
            return $responseArray;
        }
    }
}

Svaret tillbaka kommer att vara i NVP-format, och vi formatera om den till en array innan vi returnerar den.

Parameter ACK innehåller status för förfrågan:

Success

..eller:

SuccessWithWarning

…när förfrågan lyckas, och:

Error

…eller:

Warning

… när förfrågan misslyckas.

En förfrågan kan misslyckas av många anledningar, och det finns många olika skäl för varje API-metod, och dessa beskrivs i detalj i manualen. Vi ska gå igenom sätt att hantera dem lite senare. Kom ihåg att parametervärdena är skiftlägeskänsliga (skiljer på stora och små bokstäver).

 

Express Checkout

En av de mest populära API är Express Checkout, som gör att du kan ta emot betalningar utan att öppna en Website Payments Pro-konto (som endast är tillgänglig för verifierada USA konton) eller hosta själva transaktionen själv (vilket kräver ytterligare säkerhet).

Express Checkout processen fungerar på följande sätt:

1. Vi förfrågar efter en checkout token från PayPal med hjälp av transaktionsuppgifter;
2. Om det lyckas, ska vi omdirigera användaren till PayPal Checkout tillsammans med den mottagna TOKEN.
3. Användaren slutför eller avbryter betalningen på PayPal-plattformen och omdirigeras Tillbaka till Vår hemsida;
4. Vi slutför transaktionen, antingen när användaren omdirigeras tillbaka eller via en Instant Payment Notification (IPN).

PayPal - Express Checkout process
PayPal – Express Checkout process

 

 

 

1. Begär Checkout Token

Vi initiera Express Checkout processen genom att skicka in orderuppgifter till PayPal API, och får då tillbaka en token sträng som identifierar ordern. Denna token ska användas i nästa steg när vi ska omdirigera användaren till PayPal.

Här följer de parametrar som krävs:

  • METHOD
    Detta är API metod som vi använder (dvs. SetExpressCheckout).
  • RETURNURL
    Den URL som användaren kommer att omdirigeras till efter att betalningen är klar.
  • CANCELURL
    Den URL som användaren kommer att omdirigeras till efter att ha avbrutit betalningsprocessen.
  • PAYMENTREQUEST_0_AMT
    Transaktionens totala beloppet. Detta måste ha två decimaler och decimaltecknet är en punkt, och den valfria tusentalsavgränsare måste vara ett kommatecken.
  • PAYMENTREQUEST_0_ITEMAMT
    Den totala kostnaden för objekten i ordning, exklusive frakt, skatter och andra kostnader. Om det inte finns några extra kostnader, så borde det vara samma värde som PAYMENTREQUEST_0_AMT.

Vi kan ange ytterligare parametrar att lägga till mer information om ordern, varav vissa har standardvärden:

  • PAYMENTREQUEST_0_CURRENCYCODE
    Betalnings valuta, en kod på tre bokstäver. Standard är USD, för Svenska kronor är det SEK och du hittar en lista över giltiga koder på sidan Currency Codes i dokumentationen.
  • PAYMENTREQUEST_0_SHIPPINGAMT
    De totala fraktkostnaden för denna order.
  • PAYMENTREQUEST_0_TAXAMT
    Det totala skattebeloppet för denna order. Detta krävs om per-post skatten specificeras (se nedan).
  • PAYMENTREQUEST_0_DESC
    Order beskrivning.

Vi kan även lägga till information om enskilda artiklar i ordern:

  • L_PAYMENTREQUEST_0_NAMEm
    Artikelns namn.
  • L_PAYMENTREQUEST_0_DESCm
    Artikelns beskrivning.
  • L_PAYMENTREQUEST_0_AMTm
    Artikelns kostnad.
  • L_PAYMENTREQUEST_0_QTYm
    Mängden av en artikel

Variableln m identifierar en enskild artikel. (Använd samma variabel för alla detaljer i samma artikel.)

Det finns många andra valfria parametrar, som finns i API-dokumentationen. Vi kommer att använda metoden request() som vi skrev i klassen Paypal, för att bygga anropet till SetExpressCheckout:

// Parametrar till Paypal->request()
$requestParams = array(
    /* URL användaren ska skickas tillbaka till efter slutförd betalning */
    'RETURNURL' => 'http://www.yourdomain.com/payment/success',
    /* URL användaren ska skickas tillbaka till om denne avbryter betalning */
    'CANCELURL' => 'http://www.yourdomain.com/payment/cancelled'
);
$orderParams = array(
    'PAYMENTREQUEST_0_AMT' => '500', 
    'PAYMENTREQUEST_0_SHIPPINGAMT' => '4', 
    'PAYMENTREQUEST_0_CURRENCYCODE' => 'GBP', 
    'PAYMENTREQUEST_0_ITEMAMT' => '496'
);
$item = array(
    'L_PAYMENTREQUEST_0_NAME0' => 'iPhone', 
    'L_PAYMENTREQUEST_0_DESC0' => 'White iPhone, 16GB', 
    'L_PAYMENTREQUEST_0_AMT0' => '496', 
    'L_PAYMENTREQUEST_0_QTY0' => '1'
);
$paypal = new Paypal();
$response = $paypal->request('SetExpressCheckout', $requestParams . $orderParams . $item);

 

2. Omdirigera till PayPal

Om anropet till metoden är framgångsrikt, kommer vi att få en Checkout token som finns i TOKEN parametern av respons-arrayn.

if (is_array($response) && $response['ACK'] == 'Success') {
    // Anrop lyckades 
    $token = $response['TOKEN'];
    // skicka tillbaka användaren
    header('Location: https://www.paypal.com/webscr?cmd=_express-checkout&token=' . urlencode($token));
}

Användaren går nu igenom köpprocessen på PayPals webbplats. När PayPal bekräftar eller avbryter transaktionen, kommer användaren att återvända till en av de webbadresser som vi har angett i förfrågan.

 

 

3. Slutför Transaktion

Förutsatt att användaren bekräftar transaktionen, kommer dom att omdirigeras till vår hemsida genom PayPal. Nu bör vi använda två API metoder: DoExpressCheckoutPayment som kommer att slutföra transaktionen, men innan dess, kanske vi vill kanske få ytterligare information om köparen med hjälp av GetExpressCheckoutDetails.

PayPal omdirigerar användaren tillbaka från köpet tillsammans med checkout token, som vi kommer att använda för att anropa dessa metoder. Denna token kommer att finnas tillgänglig i URL-query parametern via token parametern. Vi kommer att kontrollera för dess existens i bekräftelse URL och sedan skicka våra API anrop om vi hittar den.

GetExpressCheckoutDetails metod krävde endast checkout
token. DoExpressCheckoutPayment kräver ett par ytterligare parametrar:

  • PAYMENTREQUEST_0_PAYMENTACTION
    Detta är åtgärden betalningen. Det ska vara inställd på Sale om vi inte har angett en annan åtgärd i SetExpressCheckout metoden (möjliga värden inkluderar Authorization och Capture).
  • PAYERID
    Detta är en unik identifikation för PayPal-konto. Även detta, returneras i URL-query parametrar (i PAYERID parameter) och kan även hämtas från detaljerna som returneras av GetExpressCheckoutDetails.
if (isset($_GET['token']) && !empty($_GET['token'])) { 
    // Token parameter finns
    // Hämta checkout detaljer, inklusive köparens information.
    // Vi kan spara den för framtida referens eller cross-checka med den data vi har 
    $paypal = new Paypal();
    $checkoutDetails = $paypal->request('GetExpressCheckoutDetails', array('TOKEN' => $_GET['token']));
    // Slutför checkout transaktion
    $requestParams = array(
        'TOKEN' => $_GET['token'],
        'PAYMENTACTION' => 'Sale',
        'PAYERID' => $_GET['PayerID'],
        'PAYMENTREQUEST_0_AMT' => '500', // Same amount as in the original request
        'PAYMENTREQUEST_0_CURRENCYCODE' => 'GBP' // Same currency as the originalrequest
    );
    $response = $paypal->request('DoExpressCheckoutPayment', $requestParams);
    if (is_array($response) && $response['ACK'] == 'Success') { 
        // Betalning lyckades
        // Vi hämtar transaktions-ID för intern bokföring
        $transactionId = $response['PAYMENTINFO_0_TRANSACTIONID'];
    }
}

 

 

Direkt betalning

Med Direct Payment API kan man ta emot betalningar direkt på sin webbplats/applikation, vilket ger fullständig kontroll över utcheckningsprocessen. PayPal tenderar att pusha på användare att registrera och använda ett PayPal-konto, vilket ju är förståeligt men det strider mot våra intressen, som ju är att göra betalningsprocessen som smärtfri och tydlig som möjligt för våra kunder. Av denna anledning är full kontroll över utcheckningen att föredra, och det ger oss också fler alternativ för att optimera försäljningen och genererar mer försäljning.

PayPal - Direct Payment
Processen för PayPals Direct Payment

Processen är lite enklare än Express Checkout, eftersom hela interaktionen sker på vår egen hemsida, och vi behöver endast utföra ett API-anrop för att bearbeta en normal betalning: DoDirectPayment.

Tips: Ett par fler API begäran krävs om man vill utföra en transaktion som faktureras i efterhand (till exempel när man skickar produkten eller bekräftar odrertillgänglighet). Dessa skulle vara Authorization & Capture API metoder, som jag inte kommer gå igenom i det här inlägget, men alternativet finns.

 

doDirectPayment

Direkt betalning kräver andra parametrar än Express Checkout. Medan parametrar för transaktionsdetaljer liknar varandra, kräver metoden även kreditkort och adressinformation.

doDirectPayment grundläggande parametrar:

  • METHOD
    Detta är DoDirectPayment.
  • IPADDRESS
    Detta är IP-adressen för kunden. I PHP, kan vi hämta det med hjälp av superglobaln $_SERVER[’REMOTE_ADDR’]. Du måste göra lite mer arbete för att få IP-adress när det handlar uppställningar som har en proxy mellan PHP processen och utanför nätet (t.ex. nginx).
  • PAYMENTACTION
    Detta är den typ av åtgärder som vi vill utföra. Ett värde på Sale indikerar en omedelbar transaktion. Värdet Authorization indikerar att denna transaktion inte kommer att utföras omedelbart, utan snarare kommer att fångas senare använder Authorization & Capture API nämnde tidigare.

Kreditkortsuppgifter:

  • CREDITCARDTYPE
    Kredit-korttyp (Visa, Mastercard, etc.). Se API-dokumentation för hela listan.
  • ACCT
    Den kreditkortsnummer. (Inte du älskar dessa förkortade nyckelnamn?) Detta måste överensstämma med den speciella formatet kortets typ.
  • EXPDATE
    Den utgångsdatum, i MMÅÅÅÅ format (dvs ett tvåsiffrigt månad och ett år fyrsiffrigt, som en sträng).
  • CVV2
    The ”kortverifieringsvärdet” eller säkerhetskod, som det ibland kallas.
  • Information om betalaren och adressparametrar:
  • FIRSTNAMELASTNAME
    Betalarens förnamn och efternamn, respektive (i separata fält). Du kan också ange en e-postadress i ett e-post parameter, men det är inget krav.
  • CITY, STATE, COUNTRYCODE, ZIP
    Stad, stat, landskod (kod på två bokstäver) och postnummer är delar av adressen som alla behövs.
  • STREET, STREET2
    Skapar två linjer för adressen (endast det första krävs).

Denna adress kommer att användas i address verification system (AVS). Du får en specifik felkod om en transaktion har misslyckats på grund av en adressverifierings misslyckande.

Betalningsinformation parametrarna är desamma som de för Express Checkout, men med lite olika namn (AMT, ITEMAMT, CURRENCYCODE, SHIPPINGAMT, TAXAMT och fallande) och utan PAYMENTREQUEST_0_ prefix. Se föregående avsnitt eller API-dokumentation för specifika detaljer om dem.

Likaså artikelinformation parametrar liknande dem i Express Checkout. Dessa inkluderar L_NAMEm, L_DESCm, L_AMTm och L_QTYm, vilket ger dig detaljerad kontroll över posten detaljer i ordning sammanfattningen. Den m heltal variabel används för att redovisa flera objekt (ersätt med 0, 1 och så vidare för numrerade poster i ordning). Se API-dokumentationen för en omfattande lista med artikelinformation.

 

Utföra Transaktion

Att sända en en query med vår funktion request() är mycket likt GetExpressCheckoutToken. Vi passerar alla parametrar in i queryn fungerar exakt som förut, fast med metod satt till DoDirectPayment.

$requestParams = array(
    'IPADDRESS' => $_SERVER['REMOTE_ADDR'], 
    'PAYMENTACTION' => 'Sale'
);
$creditCardDetails = array(
    'CREDITCARDTYPE' => 'MasterCard', 
    'ACCT' => '9229801207473993', 
    'EXPDATE' => '012021',  /* MMÅÅÅÅ */
    'CVV2' => '977'
);
$payerDetails = array(
    'FIRSTNAME' => 'Daniel', 
    'LASTNAME' => 'Karjanlahti', 
    'COUNTRYCODE' => 'SWE', 
    'STATE' => '',
    'CITY' => 'Södertälje', 
    'STREET' => 'Prästgårdsvägen 10.', 
    'ZIP' => '15161'
);
$orderParams = array(
    'AMT' => '500',  /* Den totala kostnaden för transaktionen till köparen. */
    'ITEMAMT' => '496',  /* Summan av kostnaden för alla Artiklar denna beställning. */
    'SHIPPINGAMT' => '4',  /* Totala fraktkostnader för denna beställning. */
    'CURRENCYCODE' => 'SEK'
);
$item = array(
    'L_NAME0' => 'iPhone',
    'L_DESC0' => 'White iPhone, 16GB', 
    'L_AMT0' => '496',
    'L_QTY0' => '1'
);
$paypal = new Paypal();
$response = $paypal->request(
        'DoDirectPayment', 
        $requestParams + 
        $creditCardDetails + 
        $payerDetails + 
        $orderParams + 
        $item
);
if (is_array($response) && $response['ACK'] == 'Success') { 
    // Betalning lyckades
    // Vi hämtar transaktions-ID för intern bokhållning
    $transactionId = $response['TRANSACTIONID'];
}

Det finns gott om parametrar, men dom är relativt enkla.

 

Felhantering

I en perfekt värld skulle detta avsnitt inte ens existerar. I verkligheten kommer du att hänvisa till det ganska mycket. PayPal kan misslyckas en transaktion för en mängd olika skäl, inte alla som kan du kontrollera.

Den $responsvariabel som vi återvänt från vår paypalApiRequest() funktionen kan innehålla ett annat värde än Success för ACK parameter. Detta värde kan vara:

  • Success
    Indikerar en lyckad operation.
  • SuccessWithWarning
    Indikerar en framgångsrik verksamhet och att meddelanden returneras i det svar som du bör undersöka.
  • Failure
    Indikerar en misslyckad operation, och att svaret innehåller en eller flera felmeddelanden som förklarar misslyckandet.
  • FailureWithWarning
    Indikerar en misslyckad operation, och att meddelanden returneras i det svar som du bör undersöka.
    Detta ger oss två framgångs status och två fel status. Den mock koden ovan tester för Success värdet bara, men vi kunde ändra det för att leta efter SuccessWithWarning också; och kom ihåg att vi måste ta reda på vad varningen är. Ett vanligt scenario är att en Direktbetalnings avgift har tagits med framgång, men kreditkortsföretaget svarar att transaktionen har misslyckats, oavsett orsak.

Fel från PayPal returneras i responsen som fyra parametrar:

  • L_ERRORCODE0
    En numerisk felkod, som kan refereras mot PayPal’s error kodlista (som är omfattande).
  • L_SHORTMESSAGE0
    En kort felmeddelande som beskriver problemet.
  • L_LONGMESSAGE0
    En längre felmeddelande som beskriver problemet.
  • L_SEVERITYCODE0
    Svårighetsgrad.

Noll-delen i dessa parametrar är ett ökande heltal för multipla felmeddelande (1, 2, etc.).

Här är några vanliga fel du kan stöta på:

  • 10002
    Autentisering eller tillstånd misslyckades. Detta tyder oftast ogiltiga API meriter eller referenser som inte matchar den typ av miljö du arbetar i (t.ex. en levande eller sandlåda miljö).
  • 81 ***
    Saknad parameter. Det finns en hel del av dessa, allt börjar med 81. Varje hänvisar till en specifik obligatorisk parameter som saknas i förfrågan.
  • 104 **
    Ogiltigt argument. Detta tyder på att en av de medföljande parametrar har ett ogiltigt värde. Varje argument har specifika fel, allt börjar med 104. En vanlig man är 10413, som innebär att den totala kostnaden för de varukorg poster matchar inte beställningens belopp (dvs. den totala mängden parametern, AMT, inte lika posterna totala plus sjöfart, hantering, skatter och andra avgifter).

 

Ta Hand om Felmeddelanden!

PayPal:s felmeddelanden varierar och kan innehålla privat information som du garanterat inte vill att dina användare att se (t.ex. en ogiltig försäljar-konfiguration). Om så är fallet, ska man inte visa dessa felmeddelanden direkt till användarna, även om vissa av dem kan vara användbara.

I de flesta fall skulle jag göra följande:

  1. Sätt upp en vit-lista rad fel som kan visas på ett säkert sätt (t.ex. en saknad kreditkortsnummer och utgångsdatum);
  2. Kontrollera svarskoden mot den arrayen;
  3. Om felmeddelandet inte är i den vita listan, visa ett generiskt felmeddelande, till exempel ”Ett fel inträffade under hanteringen av din betalning. Försök igen om några minuter, eller kontakta oss om detta är en återkommande fråga. ”

Om ett fel inte finns i den vita-listade arrayn, ska man logga det till en fil på servern och skicka ett mail till administratören, tillsammans med alla detaljer så att denne känner till misslyckade betalningar. Att loggar PayPal förfrågningar och svar är god praxis oavsett om dom innehåller felmeddelanden, så att man kan övervaka och felsöka betalnings misslyckanden.

 

Okej, det här borde få dig att komma igång med dom två populäraste PayPal alternativen Express Checkout och Direct Checkout. Till nästa gång, koda smart 😉

 

Ansvarsfriskrivning – Jag kan tyvärr inte garantera att den här artikeln resulterar i en felfri och säker applikation, och det är ditt ansvar att kontrollera din kod mot dokumentationen.

 

Huvudsaklig Källa

Att Sälja på Nätet

För att göra transaktioner på nätet behöver webbplatsen kunna utföra tre steg och det tredje steget finns har man två alternativ att välja mellan.

 

Med egen säljarkonto

  1. Cart (kundvagn) > ska samla in information om köpet, som kortnummer, adress, namn mm.
  2. Payment gateway (betalningsgateway) > krypterar informationen som samlats in och skickar den till säljarkonto.
  3. Merchant account (säljarkonto) > processar informationen och sätter in pengarna på kontot.

 

Med tredjeparts säljarkonto

  1. Kundvagn > ska samla in information om köpet, som kortnummer, adress, namn mm.
  2. Betalningsgateway > krypterar informationen och skickar den till säljarkonto
  3. Tredjepart säljarkonto > PayPal, Google Checkout m.fl. > processar informationen och sätter in pengarna på kontot

 

Det här är en första utdrag ur en serie om att skapa en nätbutikoch nästa artikel kommer alldeles strax. I den går jag igenom hur man integrerar PayPal på sin webbsida.

ER Diagram

ER Diagram är ett sätt att visualisera data och dess relationer. ER står för Entity-Relationship, vilket ungefär blir ”saker” och ”samband”. En entity i sammanhanget databaser, representerar en tabell. Relationsmodellen går ut på att data lagras i relationer, och en relation är lika med en tabell, med rader och kolumner.

 

Tupler och Attribut

Raderna brukar kallas tupler och kolumnerna attribut:

Tupler och attribut
Tupler och attribut

Så varje tupel innehåller data för en attribut. Vi ska inte gå djupare i det just nu, utan går vidare med själva visualiseringen av entiteter.

 

Exempel på ER-Diagram

Om vi nu vill visa en relation med ett ER-diagram mellan följande:

  • Fotograf kan ta flera foton
  • Foton måste tas av en fotograf
  • Foton måsta lagras på ett minneskort
  • Minneskort kan lagra många kort

…som har följande entiteter:

  • Entitet = fotograf
  • Entitet = foto
  • Entitet = minneskort

…så kan det se ut så här:

ER Relationsmodellen; fotograf, foto och minneskort
ER Relationsmodellen; fotograf, foto och minneskort

Lägg märke till linjerna mellan entiteterna, som anger på vilket sätt dom är relaterade. Här använder jag så kallade ”crow feet” eller kråkfötter, vilka man tolkar på följande sätt:

Så kallade crow feet eller kråkfötter anger relationen mellan entiteter
Så kallade crow feet eller kråkfötter anger relationen mellan entiteter

Som du ser betyder en cirkel att det är villkorligt medan ett streck betyder måste. Och det streck som är närmast entiteten betyder 1 och en gaffel betyder många. Som du såg fanns i varje entitet en övre attribut som heter id. Det är primär nyckel i fotograf,  genom den som entiteterna är kopplade till varandra.

 

Variant

En annan variant på ER-diagram ser ut så här:

ER-Relationsmodellen en annan version
ER-Relationsmodellen en annan version

I det här diagrammet används en diamant form för att specificera sambandet mellan entiteterna, och här representerar en 1:a som en och M står för många. En dubbel linje betyder att det måste vara ett/många och en enkel att det kan vara. Vidare kan du se att fotograf_namn länkar till fotograf_fnamn, och fotograf_enamn vilket betyder att man kan välja att ha med dom två andra eller bara använda fotograf_namn.

 

 

Primary Key & Foreign Key

För att kunna bygga förhållanden måste databasen vara skapad i innoDB och båda kolumnena måste vara indexerade. Och när man skapar en koppling i en databas på det här sättet så är det oftast en relatetion mellan en primary key och foreign key.

Foreign key är en nyckel som relaterar tillbaka till en primary key. En foreign key är ett fält (eller samling av fält) i en tabell som unikt identifierar en rad (primary key) i en annan tabell. Foreign key etablerar en relation, eller constraint, mellan två tabeller/entiteter. Och om man har en foreign key i en tabell måste den ha en matchande primary key i en annan tabell.

 

Typer av relationer

Det finns tre olika typerna av relationer:

  • Ett-till-ett
  • Ett-till-många
  • Många-till-många
ER Relationsmodellen; dom tre olika relationerna
ER Relationsmodellen; dom tre olika relationerna

Nu har du grundkunskaperna i hur man skapar ER-diagram och kan därför lättare planera en databas med tillhörande tabeller. Hoppas att du får användning av det här i framtiden och till nästa gång koda smart 😉

 

Lämna gärna kommentarer och om ni hittar fel ta gärna kontakt med mig.

PHP Klasser, metoder & Medlemsvariabler

Idag ska vi gå igenom PHP Klasser med tillhörande Medlemsvariabler. Och med medlemsvariabler menar jag variabler som deklareras i en klass.


Klasser & KlassNamn

När det kommer till namngivning av klasser, så ska man enligt allmänna riktlinjer och regler tänka på följande:

  • Namn måste börja med bokstav eller understreck ( _ ).
  • Och det följande tecknen måste vara; bokstäver, nummer och understreck ( _ ).
  • Det finns inga begränsningar på hur lång namnet får vara.
  • Man brukar använda ”upper camel case”, d.v.s. man skriver ihop flera ord, och första bokstaven i varje ny ord börjar med stor bokstav, då får det sammansatta ordet pucklar på ryggen som en kamel.
  • Undvika ordet class i namnet.

Att skapa en klass är enkelt och den består av 3 delar plus innehållande metoder och medlemsvariabler:

Nyckelordet class, följt av själva namnet på klassen (här ska nyckelordet extends läggas om man utökar en klass) och sedan ett par klammerparentes – {}:

class KlassNamn {
   /*** metoder och medlemsvariabler ***/
}

Här följer ett par exempel på namngivning av klasser:

class Namn {}
class EttNamn {}
class Ett_Namn {}
/* Alla 3 Följer god praxis, då varje ord börjar med stor bokstav */

class ett_namn {}
/* detta är giltigt men följer inte god praxis */

class 1_Namn {}
/* inte ett giltigt klassnamn, då den börjar med en bokstav */

Medlemsvariabler

Medlemsvariabler är variabler som skrivs in i klasser, och förefås alltid av nyckelordet; public, protected eller private. Om man utelämnar nyckelordet får man en ”parse error” och PHP avbryter exekvering. Så, vad ska man välja? Det är här metoder kommer in i bilden och fungerar som klassens reglage, och behöver därför oftast vara public, medan medlemsvariabler bör skyddas med protected eller private så att ingen kommer åt dom avsiktligt eller oavsiktligt.

  • Precis som klasser måste dom börja med en bokstav eller ett understreck ( _ ).
  • Följande tecken måste vara; bokstäver, nummer och understreck.
  • Och det finns ingen begränsning på längd
  • Man brukar använda ”lower camel case”, där det första ordet skrivs med små bokstäver och varje ny ord börjar med stor bokstav.
  • När det kommer till understreck i början så används det för att tydliggöra att en variabel har begränsad synliget, d.v.s. använder nyckelordet portected eller private

För att modifiera egenskaper använder man sig av getter och setter metoder.

Exempel på setter och getter metoder:

Vi börjar med att skapa en klass som vi kan bygga under den här artikeln. Den ska representera en fysisk adress, så det naturliga namnvalet blev Adress, och eftersom man så gott som alltid namnger på Engelska blir det Address