2006-10-30
Copyright © 1997-2006 the PHP Documentation Group
Copyright © 2000-2006 A PHP dokumentáció magyar fordítói
Copyright
Copyright © 1997 - 2006 by the PHP Documentation Group. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later. A copy of the Open Publication License is distributed with this manual, the latest version is presently available at http://www.opencontent.org/openpub/.
Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.
Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
In case you are interested in redistribution or republishing of this document in whole or in part, either modified or unmodified, and you have questions, please contact the copyright holders at doc-license@lists.php.net. Note that this address is mapped to a publicly archived mailing list.
The 46 fejezet section of the documentation is based on an initial contribution by Zend Technologies.
A magyar copyright megegyezik az angol feltételekkel. Az Open Publication License egy másolata ezen dokumentációhoz csatolva is olvasható. A PHP kézikönyv magyar fordításának oldala a http://wfsz.njszt.hu/projektek_phpdoc.php címen található. A fordítók nevei szintén a fedlapon olvashatóak.
A PHP, bővebben "PHP: Hypertext Preprocessor" egy széles körben használt, nyílt forráskódú, általános célú programozási nyelv, különösen jó web-fejlesztés támogatással, és HTML-be ágyazási képességekkel. A szintakszisa a C, Java és Perl nyelvekre épül, könnyen megtanulható. A nyelv fő célja lehetőséget teremteni dinamikusan generált weboldalak gyors készítésére, de a PHP ennél sokkal többre is képes.
Ez a kézikönyv legfőképpen függvény referenciaként használható, azonban a nyelvi elemek ismertetése is megtalálható benne, a főbb PHP szolgáltatások leírása, és más kapcsolódó információk mellett.
Ez a kézikönyv számos nyelven és formátumban letölthető a http://www.php.net/download-docs.php címen. Ha érdekel, hogyan készül ez a kézikönyv, olvasd el az 'About the manual' című függeléket. Ha a PHP történetére vagy kíváncsi, olvasd el az idevontakozó függeléket.
A magyar kézikönyvet téritésmentesen készítjük, szabadidőnkben. A le nem fordított fejezetek mindig a legfrissebb angol szöveggel jelennek meg, ezért vegyes nyelvű oldalakkal igen ritkán fogsz találkozni. Időnként az azonban előfordulhat, hogy bizonyos már lefordított fejezetek nem teljesen aktuálisak. Emiatt ha mindig aktuális és pontos információra van szükséged, és értesz angolul, érdemes ezt a kézikönyvet az angol változattal párhuzamosan használni. Az esetleges kellemetlenségekért elnézést kérünk, bár felelősséget természetesen nem tudunk vállalni.
A PHP kézikönyv magyar fordítása a Neumann János Számítógép-tudományi Társaság Webalkalmazások Fejlesztése Szakosztályának egyik projektje. A fordítás oldala a http://wfsz.njszt.hu/projektek_phpdoc.php címen található. Ha szeretnél bekapcsolódni a fordításba, látogasd meg ezt a címet.
Az utóbbi idők leginkább aktív szerzőit soroljuk fel a kézikönyv fedőlapján, de fontos megjegyeznünk, hogy sokkal több hozzájáruló segítő dolgozik jelenleg is a PHP dokumentáción, és még többen segítettek a múltban. Szintén sok névtelen személy van, akik beküldött megjegyzéseikkel, kommentárjaikkal egészítették ki a kézikönyvet, hiszen ezeket időről időre beépítjük az oldalakba. Minden alább látható lista ábécésorrendben sorolja fel a segítőket.
A következő hozzájáruló segítők a kézikönyv írásával, kibővítésével jelentős mértékben hatottak a jelenlegi tartalomra: Jouni Ahto, Alexander Aulbach, Daniel Beckham, Stig Bakken, Jesus M. Castagnetto, Ron Chmara, Sean Coates, John Coggeshall, Simone Cortesi, Markus Fischer, Wez Furlong, Sara Golemon, Rui Hirokawa, Brad House, Moriyoshi Koizumi, Rasmus Lerdorf, Andrew Lindeman, Stanislav Malyshev, Rafael Martinez, Yasuo Ohgaki, Derick Rethans, Sander Roobol, Egon Schmid, Thomas Schoefbeck, Sascha Schumann, Dan Scott, Lars Torben Wilson, Jim Winstead, Jeroen van Wolffelaar és Andrei Zmievski.
A következő hozzájáruló segítők jelentős munkát fektettek a kézikönyv szerkesztésébe: Stig Bakken, Gabor Hojtsy, Hartmut Holzgraefe és Egon Schmid.
A jelenleg legaktívabb karbantartók: Mehdi Achour, Friedhelm Betz, Vincent Gevers, Aidan Lister, Nuno Lopes és Tom Sommer.
A következő személyeket szintén köszönet illeti jelentős részvételükért: Daniel Beckham, Victor Boivie, Jesus M. Castagnetto, Nicolas Chaillan, Ron Chmara, James Cox, Sara Golemon, Zak Greant, Szabolcs Heilig, Oliver Hinckel, Hartmut Holzgraefe, Rasmus Lerdorf, Andrew Lindeman, Maxim Maletsky, James Moore, Sebastian Picklum, Derick Rethans, Sander Roobol, Damien Seguy, Jason Sheets, Jani Taskinen, Yasuo Ohgaki, Philip Olson, Lars Torben Wilson, Jim Winstead, Jared Wyles és Jeroen van Wolffelaar.
A PHP (rekurzív rövidítéssel "PHP: Hypertext Preprocessor") széles körben használt általános célú szkriptnyelv, amely kifejezetten alkalmas - akár HTML-be ágyazott - webalkalmazások fejlesztésére.
Egyszerű meghatározás, de mit is jelent ez valójában? Egy példán bemutatva:
Vedd észre, hogy ez mennyire különbözik más nyelveken (például Perl vagy C) írt hagyományos szkripttől. Sok parancsból álló programok helyett csak egy HTML fájlba kell egy kevés programkódot beépíteni, hogy a megfelelő HTML kimenetet produkálja. A PHP kódblokkokat speciális kezdő és befejező jelölések közé kell elhelyezni, és ezek biztosítják, hogy a feldolgozás során a váltogathasd a "PHP módot".
Az különbözteti meg a PHP-t a kliens oldali nyelvektől - pl. JavaScript -, hogy a kód a kiszolgálón fut. Az első példában látható oldal eredményét böngészőben megnézve, nem lehet megállapítani, hogy milyen kód állíthatta azt elő. Ezen felül a webszervert be lehet állítani úgy, hogy a PHP feldolgozzon minden HTML fájlt PHP blokkokat keresve, ezek után már tényleg nincs rá mód, hogy kitalálják, mit is rejt egy-egy programod.
A legjobb dolog a PHP használatában, hogy különösen egyszerű egy kezdő számára, de számos, fejlett szolgáltatást nyújt professzionális programozó számára is. Ne ijesszen el a PHP hosszú szolgáltatás listája. Gyors léptekkel lehet haladni a PHP használatában, és pár órán belül már egyszerű szkriptek írására is képes lehetsz.
Habár a PHP fejlesztésében a szerver-oldali programozás kapja a legnagyobb hangsúlyt, annál sokkal többet tud. Olvasd tovább ezt a fejezetet a Mit tud a PHP? című résszel folytatva, vagy ugorj el a bevezető oktatóanyagunkra, ha csupán úgy általában vagy kíváncsi a web programozására.
Bármit. A PHP főleg szerver-oldali szkriptek írására készült, azaz bármire képes, amit más CGI programok el tudnak végezni, ilyen funkciók az űrlap adatok feldolgozása, dinamikus tartalom generálása, vagy sütik küldése és fogadása. De a PHP ennél sokkal többet tud.
Három fő területen használnak PHP programokat.
Szerver oldali programozás. Ez a hagyományos, és fő használati formája a PHP-nek. Három komponens szükséges ahhoz, hogy ezt a formát használhasd. Az első a PHP értelmező (CGI vagy szerver modul formájában), egy webszerver és egy webböngésző. Egy webszerverrel mindenképpen rendelkezni kell, megfelelően telepített és beállított PHP-vel. A PHP program kimenetét a webböngészővel lehet megtekinteni, a szerveren keresztül elérve a szkriptet. Mindezek képesek elutni a te otthoni gépeden is, ha csupán csak ismerkedni kívánsz a nyelvvel. Lásd a telepítési utasításokatc. részt további információkért!
Parancssori programozás. PHP programok szerver és böngésző nélkül is futtathatóak. Ha ilyen környezetben szeretnéd használni a PHP-t, csak a PHP értelmezőre van szükséged. Ebben a formában gyakran valamilyen ütemező program segítségével (cron *nix és Linux alatt, Task Scheduler Windows alatt) futtatott programokat írnak, vagy egyszerű szövegfeldolgozó szkripteket készítenek. Lásd a Parancssori használat című függeléket további információért!
Ablakozós alkalmazások írása. A PHP valószínűleg nem a legjobb nyelv grafikus felületű asztali alkalmazások írásához, de ha nagyon jól ismered a PHP-t, és szeretnél néhány fejlett PHP szolgáltatást használni a kliens-oldali programjaidban, a PHP-GTK-t is használhatod ilyen programok írásához. Ezt használva lehetőséged van operációs rendszerfüggetlen programok írására is. A PHP-GTK a PHP egy kiterjesztése, nem érhető el a hivatalos PHP csomagban. Ha további információkra van szükséged látogsd meg a PHP-GTK webhelyet!
A PHP használható a legfontosabb operációs rendszereken, beleértve a Linuxot, sok Unix változatot (beleértve a HP-UX, Solaris és OpenBSD rendszereket), a Microsoft Windows-t, a Mac OS X rendszert, a RISC OS-t, és másokat. A PHP a legtöbb webszervert is támogatja, beleértve az Apache, Microsoft Internet Information Server, Personal Web Server, Netscape és iPlanet szervereket, az Oreilly Website Pro, Caudium, Xitami, OmniHTTPd, és más szervereket. A legtöbb szerverhez a PHP modul szintű támogatást nyújt, de más a CGI szabványt támogató szerverekkel is együtt tud működni CGI feldolgozóként.
Összességében a PHP használatakor szabadon választhatsz operációs rendszert és webszervert. Ráadásul a függvény-alapú és objektum orientált programozás, vagy ezek keveréke közötti választás is rajtad áll. Bár nem minden szokásos OOP szolgáltatás került megvalósításra a PHP 4-es változatában, sok eljáráskönytár és nagyobb alkalmazás is az OOP-t használja, például a PEAR könyvtár. A PHP 5-ös változata helyreteszi a PHP 4 OOP terén mutatott gyengeségeit, teljes objektum modell áll rendelkezésünkre.
A PHP képességei nem csak HTML kimenet előállítására korlátozódnak. Képeket, PDF állományokat vagy akár Flash mozikat (libswf vagy Ming kiterjesztéssel) is létrehozhatsz futásidőben. Természetesen egyszerűen generálhatsz bármilyen szöveges kimenetet, mint az XHTML vagy bármilyen más XML. A PHP elő tudja állítani ezeket az állományokat, és el tudja menteni a szerven a közvetlen kiküldésük helyett, valamilyen szerver-oldali gyorsítótárat valósítva meg ezzel.
Az egyik legjobb és legfontosabb tulajdonsága a nyelvnek az adatbázisok széles körű támogatása. Adatbázisokat kezelő weblap készítése PHP segítségével hihetetlenül egyszerű. A következő adatbázisok támogatja jelenleg:
A PHP rendelkezik egy DBX adatbázis absztrakciós kiterjesztéssel is, amellyel egyöntetűen és áttetszű módon lehet kezelni bármilyen adatbázist, amit ez a kiterjesztés támogat. Ezen kívül a PHP támogatja az ODBC-t, ezért bármilyen más, ezt a szabványt támogató adatbázishoz is lehet kapcsolódni.
Adabas D InterBase PostgreSQL dBase FrontBase SQLite Empress mSQL Solid FilePro (csak olvasásra) Direct MS-SQL Sybase Hyperwave MySQL Velocis IBM DB2 ODBC Unix dbm Informix Oracle (OCI7 és OCI8) Ingres Ovrimos
A PHP támogatja a kommunikációt más szolgáltatásokkal is különböző protokollok segítségével, úgy mint LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (Windows rendszeren), és számos más. Sőt, nyithatsz hálózati foglalatokat is (socket) és kommunikálhatsz más protokolokkal is. A PHP támogatja a WDDX komplex adatcseréket, ami bármely más web programozási nyelvvel való kommunikációt megkönnyíheti. A PHP szintén rendelkezik a Java objektumok létrehozásának, és átlátszóan PHP objektummokként való kezelésének képességével. A CORBA kiterjesztés távoli objektumok elérésére használható.
A PHP rendkívül jó szövegfeldolgozó képességekkel rendelkezik, a POSIX és Perl reguláris kifejezésektől az XML állományok kezeléséig. Az XML dokumentumok feldologozásához és eléréséhez PHP4-ben a SAX és DOM szabványok is használhatóak, Az XSLT kiterjesztés XML dokumentumok általakítására használható. A PHP 5 az XML kapcsolatos feladatokat egységesen, a libxml2 függvénykönyvtárra támaszkodva látja el. Ezen biztos alapokon a PHP 5 bevezeti a SimpleXML és az XMLReader támogatást is.
Ha elektornikus üzleti környezetben használod a PHP-t, hasznosnak fogod találni a Cybercash, CyberMUT, VerySign Payflow Pro and MCVE függvényeket az internetes fizetést megvalósító programokban.
Végül, de nem utolsósorban a PHP számos más érdekes kiterjesztéssel szolgálhat, mint például az mnoGoSearch kereső függvények, az IRC átjáró függvények, tömörítő eszközök (gzip, bz2), naptár átalakítás, fordítás...
Ahogy látható, ez az oldal nem elegendő a PHP minden szolgáltatásának és előnyének felsorolásához. Lásd a PHP telepítése és a függvény referencia részeket további információkért!
Here we would like to show the very basics of PHP in a short, simple tutorial. This text only deals with dynamic webpage creation with PHP, though PHP is not only capable of creating webpages. See the section titled What can PHP do for more information.
PHP-enabled web pages are treated just like regular HTML pages and you can create and edit them the same way you normally create regular HTML pages.
In this tutorial we assume that your server has activated support for PHP and that all files ending in .php are handled by PHP. On most servers, this is the default extension for PHP files, but ask your server administrator to be sure. If your server supports PHP, then you do not need to do anything. Just create your .php files, put them in your web directory and the server will automatically parse them for you. There is no need to compile anything nor do you need to install any extra tools. Think of these PHP-enabled files as simple HTML files with a whole new family of magical tags that let you do all sorts of things. Most web hosts offer PHP support, but if your host does not, consider reading the PHP Links section for resources on finding PHP enabled web hosts.
Let us say you want to save precious bandwidth and develop locally. In this case, you will want to install a web server, such as Apache, and of course PHP. You will most likely want to install a database as well, such as MySQL.
You can either install these individually or choose a simpler way. Our manual has installation instructions for PHP (assuming you already have some webserver set up). In case you have problems with installing PHP yourself, we would suggest you ask your questions on our installation mailing list. If you choose to go on the simpler route, then locate a pre-configured package for your operating system, which automatically installs all of these with just a few mouse clicks. It is easy to setup a web server with PHP support on any operating system, including MacOSX, Linux and Windows. On Linux, you may find rpmfind and PBone helpful for locating RPMs. You may also want to visit apt-get to find packages for Debian.
Create a file named hello.php and put it in your web server's root directory (DOCUMENT_ROOT) with the following content:
This program is extremely simple and you really did not need to use PHP to create a page like this. All it does is display: Hello World using the PHP echo() statement. Note that the file does not need to be executable or special in any way. The server finds out that this file needs to be interpreted by PHP because you used the ".php" extension, which the server is configured to pass on to PHP. Think of this as a normal HTML file which happens to have a set of special tags available to you that do a lot of interesting things.
If you tried this example and it did not output anything, it prompted for download, or you see the whole file as text, chances are that the server you are on does not have PHP enabled, or is not configured properly. Ask your administrator to enable it for you using the Installation chapter of the manual. If you are developing locally, also read the installation chapter to make sure everything is configured properly. Make sure that you access the file via http with the server providing you the output. If you just call up the file from your file system, then it will not be parsed by PHP. If the problems persist anyway, do not hesitate to use one of the many PHP support options.
The point of the example is to show the special PHP tag format. In this example we used <?php to indicate the start of a PHP tag. Then we put the PHP statement and left PHP mode by adding the closing tag, ?>. You may jump in and out of PHP mode in an HTML file like this anywhere you want. For more details, read the manual section on the basic PHP syntax.
A Note on Line Feeds: Line feeds have little meaning in HTML, however it is still a good idea to make your HTML look nice and clean by putting line feeds in. A linefeed that follows immediately after a closing ?> will be removed by PHP. This can be extremely useful when you are putting in many blocks of PHP or include files containing PHP that aren't supposed to output anything. At the same time it can be a bit confusing. You can put a space after the closing ?> to force a space and a line feed to be output, or you can put an explicit line feed in the last echo/print from within your PHP block.
A Note on Text Editors: There are many text editors and Integrated Development Environments (IDEs) that you can use to create, edit and manage PHP files. A partial list of these tools is maintained at PHP Editors List. If you wish to recommend an editor, please visit the above page and ask the page maintainer to add the editor to the list. Having an editor with syntax highlighting can be helpful.
A Note on Word Processors: Word processors such as StarOffice Writer, Microsoft Word and Abiword are not optimal for editing PHP files. If you wish to use one for this test script, you must ensure that you save the file as plain text or PHP will not be able to read and execute the script.
A Note on Windows Notepad: If you are writing your PHP scripts using Windows Notepad, you will need to ensure that your files are saved with the .php extension. (Notepad adds a .txt extension to files automatically unless you take one of the following steps to prevent it.) When you save the file and are prompted to provide a name for the file, place the filename in quotes (i.e. "hello.php"). Alternatively, you can click on the 'Text Documents' drop-down menu in the 'Save' dialog box and change the setting to "All Files". You can then enter your filename without quotes.
Now that you have successfully created a working PHP script, it is time to create the most famous PHP script! Make a call to the phpinfo() function and you will see a lot of useful information about your system and setup such as available predefined variables, loaded PHP modules, and configuration settings. Take some time and review this important information.
Let us do something more useful now. We are going to check what sort of browser the visitor is using. For that, we check the user agent string the browser sends as part of the HTTP request. This information is stored in a variable. Variables always start with a dollar-sign in PHP. The variable we are interested in right now is $_SERVER['HTTP_USER_AGENT'].
Megjegyzés: $_SERVER is a special reserved PHP variable that contains all web server information. It is known as an autoglobal (or superglobal). See the related manual page on superglobals for more information. These special variables were introduced in PHP 4.1.0. Before this time, we used the older $HTTP_*_VARS arrays instead, such as $HTTP_SERVER_VARS. Although deprecated, these older variables still exist. (See also the note on old code.)
To display this variable, you can simply do:
There are many types of variables available in PHP. In the above example we printed an Array element. Arrays can be very useful.
$_SERVER is just one variable that PHP automatically makes available to you. A list can be seen in the Reserved Variables section of the manual or you can get a complete list of them by looking at the output of the phpinfo() function used in the example in the previous section.
You can put multiple PHP statements inside a PHP tag and create little blocks of code that do more than just a single echo. For example, if you want to check for Internet Explorer you can do this:
Példa 2-4. Example using control structures and functions
A sample output of this script may be:
|
Here we introduce a couple of new concepts. We have an if statement. If you are familiar with the basic syntax used by the C language, this should look logical to you. Otherwise, you should probably pick up an introductory PHP book and read the first couple of chapters, or read the Language Reference part of the manual. You can find a list of PHP books at http://www.php.net/books.php.
The second concept we introduced was the strpos() function call. strpos() is a function built into PHP which searches a string for another string. In this case we are looking for 'MSIE' (so-called needle) inside $_SERVER['HTTP_USER_AGENT'] (so-called haystack). If the needle is found inside the haystack, the function returns the position of the needle relative to the start of the haystack. Otherwise, it returns FALSE. If it does not return FALSE, the if expression evaluates to TRUE and the code within its {braces} is executed. Otherwise, the code is not run. Feel free to create similar examples, with if, else, and other functions such as strtoupper() and strlen(). Each related manual page contains examples too. If you are unsure how to use functions, you will want to read both the manual page on how to read a function definition and the section about PHP functions.
We can take this a step further and show how you can jump in and out of PHP mode even in the middle of a PHP block:
Példa 2-5. Mixing both HTML and PHP modes
A sample output of this script may be:
|
Instead of using a PHP echo statement to output something, we jumped out of PHP mode and just sent straight HTML. The important and powerful point to note here is that the logical flow of the script remains intact. Only one of the HTML blocks will end up getting sent to the viewer depending on the result of strpos(). In other words, it depends on whether the string MSIE was found or not.
One of the most powerful features of PHP is the way it handles HTML forms. The basic concept that is important to understand is that any form element will automatically be available to your PHP scripts. Please read the manual section on Variables from outside of PHP for more information and examples on using forms with PHP. Here is an example HTML form:
There is nothing special about this form. It is a straight HTML form with no special tags of any kind. When the user fills in this form and hits the submit button, the action.php page is called. In this file you would write something like this:
Apart from the htmlspecialchars() and (int) parts, it should be obvious what this does. htmlspecialchars() makes sure any characters that are special in html are properly encoded so people can't inject HTML tags or Javascript into your page. For the age field, since we know it is a number, we can just convert it to an integer which will automatically get rid of any stray characters. You can also have PHP do this for you automatically by using the filter extension. The $_POST['name'] and $_POST['age'] variables are automatically set for you by PHP. Earlier we used the $_SERVER autoglobal; above we just introduced the $_POST autoglobal which contains all POST data. Notice how the method of our form is POST. If we used the method GET then our form information would live in the $_GET autoglobal instead. You may also use the $_REQUEST autoglobal, if you do not care about the source of your request data. It contains the merged information of GET, POST and COOKIE data. Also see the import_request_variables() function.
You can also deal with XForms input in PHP, although you will find yourself comfortable with the well supported HTML forms for quite some time. While working with XForms is not for beginners, you might be interested in them. We also have a short introduction to handling data received from XForms in our features section.
Now that PHP has grown to be a popular scripting language, there are a lot of public repositories and libraries containing code you can reuse. The PHP developers have largely tried to preserve backwards compatibility, so a script written for an older version will run (ideally) without changes in a newer version of PHP. In practice, some changes will usually be needed.
Two of the most important recent changes that affect old code are:
The deprecation of the old $HTTP_*_VARS arrays (which need to be indicated as global when used inside a function or method). The following autoglobal arrays were introduced in PHP 4.1.0. They are: $_GET, $_POST, $_COOKIE, $_SERVER, $_FILES, $_ENV, $_REQUEST, and $_SESSION. The older $HTTP_*_VARS arrays, such as $HTTP_POST_VARS, still exist as they have since PHP 3. Az 5.0.0 változattól kezdődően az előre definiált hosszú PHP változók létrehozása kikapcsolható a register_long_arrays direktíva segítségével.
External variables are no longer registered in the global scope by default. In other words, as of PHP 4.2.0 the PHP directive register_globals is off by default in php.ini. The preferred method of accessing these values is via the autoglobal arrays mentioned above. Older scripts, books, and tutorials may rely on this directive being on. If it were on, for example, one could use $id from the URL http://www.example.com/foo.php?id=42. Whether on or off, $_GET['id'] is available.
With your new knowledge you should be able to understand most of the manual and also the various example scripts available in the example archives. You can also find other examples on the php.net websites in the links section: http://www.php.net/links.php.
To view various slide presentations that show more of what PHP can do, see the PHP Conference Material Sites: http://conf.php.net/ and http://talks.php.net/
Mielőtt hozzálátnál a telepítéshez, meg kell tudnod határozni, hogy mire akarod használni a PHP-t. A Mire jó a PHP? című fejezetben leírt következő három fő területen használhatod:
Szerveroldali programozásra
Parancssori programok írására
Kliens oldali GUI alkalmazások kifejlesztéséhez.
Az első és legszokványosabb használatához három dologra lesz szükséged: magára a PHP-re, egy webszerverre és egy webböngészőre. Valőszínűleg már rendelkezel böngészővel, és az operációs rendszer telepítésétől függően webszervered is lehet (Linux és MacOS X alatt Apache, Windows alatt IIS). Bérelhetsz tárterületet egy cégtől is, ebben az esetben neked nem kell semmit telepítened, csak a PHP szkripteket megírni és feltölteni őket a bérelt webtárhelyedre és nézni a végeredményt a böngészőben.
Ha saját magad telepíted a PHP-t, akkor kétféleképpen csatlakoztathatod a kiszolgálóhoz. A PHP-nek rengeteg kiszolgálóhoz van közvetlen modulinterfésze (SAPI). Ezek a szerverek az Apache, Microsoft Internet Information Server, Netscape és az iPlanet. Ezenkívül sok szerver támogatja az ISAPI-t, a Microsoft modulinterfészét mint pl. az OmniHTTPd. Ha PHP-nek nem létezika a webszerveredhez modul, mindig lehetőséged van CGI vagy FastCGI feldolgozóként futtatni. Ez azt jelenti, hogy úgy állítod be a webszerveredet, hogy a PHP CGI programját használja a PHP fájlokra érkezett kérések kiszolgálására.
Ha a PHP-t parancssori programozásra is szeretnéd használni (pl. offline képgenerálást végző szkript, vagy szöveges fájlok feldolgozása az átadott argumentumoktól függően), mindenképpen a futtatható állományra lesz szükséged. További információért lásd a Parancssori PHP alkalmazások írása című részt. Ebben az esetben nem lesz szükséged szerverre és böngészőre.
A PHP és a PHP-GTK kiterjesztés segítségével kliens oldali GUI alkalmazásokat is fejleszthetsz. Ez teljesen eltérő megközelítés, mint a weboldalak programozása, mivel itt nem HTML kimenetet kell generálni, hanem ablakokat és a bennük levő objektumokat kell kezelni. A PHP-GTK-ról többet is olvashatsz, ha ellátogatsz a honlapjára. A PHP-GTK nem része a hivatalos PHP disztribuciónak.
Ettől a ponttól ez a fejezet a PHP webszerverhez történő telepítésével foglalkozik, Unix és Windows alatt, modulként és CGI feldolgozóként. A futtatható állományról is találsz információt a következő részekben.
A forráskód és a futtatható állományok Windows-ra megtalálhatóak http://www.php.net/downloads.php címen. Ha lehet, akkor valamelyik hozzád legközelebb eső tükörszervert vedd igénybe a letöltésekhez.
Ez a fejezet bemutatja, hogy miként kell feltelepíteni és beállítani a PHP-t Unix rendszeren. Mielőtt elkezded a telepítést, nézd meg a rendszerednek ás szerverednek megfelelő fejezetet is!
Mint ahogy azt kézikönyvünk az Általános telepítési szempontok című részben felvázolta, ebben a részben legfőképpen a web-centrikus telepítésekkel foglalkozunk, bár a PHP parancssori használatának telepítését is tárgyaljuk.
Számos módja van a PHP telepítésének a Unix rendszereken, vagy egy fordítási és konfigurálási eljárással, vagy különböző előre-csomagolt megoldások használatával. Ez a dokumentáció legfőképpen a fordítási és konfigurálási folyamatokra fekteti a hangsúlyt. Sok Unix-féle rendszernek van valamilyen telepítőrendszere. Ez segít feltelepíteni egy általános konfigurációt, de ha különböző szolgáltatáskészleteket szeretnél (mint például egy biztonságos szerver, vagy különböző adatbázis-meghajtók), magad kell fordítanod a PHP és/vagy a webszervert. Ha nem vagy jártas saját szoftver fordításában, jobb, ha utánanézel, hogy valaki már lefordított-e egy olyan PHP csomagot, amilyet szeretnél.
A fordításhoz nélkülözhetetlen előismeretek és szoftverek:
Alapvető Unix ismeretek ("make" és a C fordító használata)
Egy ANSI C fordító
flex: 2.5.4-es verzió
bison: 1.28-as (ajánlott), 1.35-ös, vagy 1.75-ös verzió
A web server
Bármilyen modul által igényelt elem (mint például a gd vagy pdf könyvtárak, stb.)
Az alapvető konfigurálási folyamatot a configure számára átadott parancssori paraméterek szabályozzák. A ./configure --help paranccsal kérhetsz egy listát a rendelkezésreálló opciókról, rövid magyarázatokkal. Ez a kézikönyv külön tárgyalja a különböző opciókat. Az alapvető opciókat a függelékben találod, a különböző kiterjesztés-specifikus opciók pedig a referencia oldalakon vannak leírva.
Amikor a PHP konfigurálása megtörtént, elkezdheted létrehozni a modulokat és/vagy a végrehajtható állományokat. A make parancs ezt el kell tudja intézni. Ha hiba lép fel, és nem tudod elképzelni, hogy miért, olvasd el a problémákról szóló részt.
Ez a rész a PHP Apache-hoz történő telepítéséhez tartalmaz megjegyzéseket és javaslatokat Unix rendszerek esetén. Az Apache 2-höz tartozó útbaigazítások és javaslatok külön oldalon találhatóak.
A 10. sorban a configure-nak átadandó argumentumokat a az alapvető konfigurációs beállítások listájából valamint a kiterjesztésekhez tartozó beállításokat a kézikönyv megfelelő részeiből válogathatod ki. A verziószámokat itt elhanyagoltuk, hogy bizonyosak legyünk abban, hogy az utasítások nem helytelenek. Az 'xxx' helyébe a fájlok neveiből származó megfelelő értékeket kell majd behelyettesítened.
Példa 4-1. Telepítési parancsok (Apache osztott modul verzió) PHP-hez
|
A PHP-t statikus objektumként is telepítheted:
Példa 4-2. Telepítési parancsok (Apache statikus modul verzió) PHP-hez
|
Az Apache telepítéstől és a Unix változattól függően, több módon lehet a szervert leállítani vagy újraindítani. Az alábbiakban felsorolunk néhány a tipikus sorokat amelyeket különböző apache/unix konfigurációkon szerver-újraindításra használnak. Az /útvonal/ helyébe helyettesítsd a megfelelő alkalmazás útvonalát.
Példa 4-3. Példa-utasítások az Apache újraindításához
|
Az apachectl és a http(s)dctl helyen gyakran változik. Ha van a rendszeredben locate, whereis vagy which parancs, ezek segíthetnek megtalálni a szervervezérlő programokat.
Itt egy másik példa a PHP Apache-hoz való fordítására:
Ez létrehozza a libphp4.so osztott könyvtárat ami az Apache-ba töltödik be a httpd.conf LoadModule sora által A PostgreSQL támogatás bele van építve ebbe a libphp4.so fájlba. library.
Ez létrehoz egy libphp4.so osztott könyvtárat az Apache számára, de egy pgsql.so osztott könyvtérat is készít, amely a PHP-be a php.ini extension direktívája által vagy a szkriptben szereplő dl() függvénnyel kerül betöltésre.
Ez létrehoz egy libmodphp4.a könyvtárat, egy mod_php4.c-t és néhány velejáró fájlt és bemásolja ezeket az Apache forrásfájának src/modules/php4 könyvtárába. Ezután lefordítod az Apache-t --activate-module=src/modules/php4/libphp4.a opcióval, majd az Apache fordító rendszere létrehozza a libphp4.a-t, majd statikusan belinkeli a httpd binárisba. A PostgreSQL támogatás közvetlenül ebben a httpd binárisban van benne, így a végeredmény egy egyedüli httpd bináris, ami tartalmazza az egész Apache-t és az egész PHP-t.
Ez hasonló az előzővel, kivéve, hogy a PostgreSQL-t nem építjük közvetlenül bele a végső httpd-be, hanem készítünk egy pgsql.so osztott könyvtárat, amit betölthetsz a PHP-be php.ini-ből, vagy a dl() függvénnyel.
Amikor a PHP különféle fordítási módjai közül választasz, figyelembe kell venned a különböző módszerek előnyeit és hátrányait. Ha osztott fájlt hozol létre, az Apache-t külön fordíthatod, és nem kell mindent újrafordítanod, ha valamit hozzá akarsz adni, vagy módosítani a PHP-ben. Ha a PHP az Apache-ba építed be, azt jelenti, hogy a PHP gyorsan töltődik be és gyorsan fut. További információkért lásd az Apache DSO támogatásról szóló weboldalát.
Megjegyzés: Az Apache alapértelmezett httpd.conf fájlja jelenleg egy hasonló részt tartalmaz:
Amíg nem változtatod meg "Group nogroup"-ra vagy valami hasonlóra (a "Group daemon" elég általános) a PHP nem fog tudni fájlokat megnyitni.
Megjegyzés: Győződj meg róla, hogy az Apache-nak a telepített verzióját adod meg a --with-apxs=/útvonal/apxs opcióban. NE használd a apache forráskódban szereplű apxs verziót, hanem azt, amelyik ténylegesen telepítve van a rendszeredre.
Ez a rész a PHP Apache 2.0-hoz történő telepítéséhez tartalmaz megjegyzéseket és javaslatokat Unix rendszerek esetén.
| Figyelem |
Nem ajánljuk az Apache2 threaded MPM-jének alkalmazását éles környezetben. Ehelyett a prefork MPM használata, vagy az Apache 1.3-as változatának használata javallott. Ha kíváncsi vagy a miértekre, olvasd el a kapcsolódó FAQ bejegyzést: Apache2 with a threaded MPM! |
Erősen ajánljuk, hogy tanulmányozd az Apache dokumentációt, hogy alapvelően megértsd az Apache 2.0 Server működését.
PHP és Apache 2.0.x kompatibilitása: A PHP alábbi verziói biztosan működnek az Apache 2.0.x legújabb verziójával:
A PHP ezen verziói kompatibilisek az Apache 2.0.40-ás és későbbi verzióival.
- PHP 4.3.0 vagy későbbi, elérhető itt: http://www.php.net/downloads.php.
- a legfrisseb stabil fejlesztői verzió. A forráskód letöltése: http://snaps.php.net/php4-latest.tar.gz, Windows binárisok letöltése: http://snaps.php.net/win32/php4-win32-latest.zip.
- prerelease verzió, letölthető itt: http://qa.php.net/.
- bármikor letöltheted a PHP-t anonymous CVS-el.
Az Apache 2.0 SAPI-támogatása a PHP 4.2.0-ás verziójával kezdődött. A PHP 4.2.3 az Apache 2.0.39-el működik, ne használj más Apache verziót vele. Az ajánlott konfiguráció: PHP 4.3.0 vagy frissebb, és az Apache2 legfrissebb verziója.
A PHP minden említett verziója továbbra is működik az Apache 1.3.x verziójával.
Töltsd le az Apache 2.0 legűjabb verzióját és a PHP-nek egy megfelelő verzióját a fent említett helyekről. Ez a gyors útmutató csak az alapokat tartalmazza az Apache 2.0 és a PHP használatával kapcsolatban. További információért olvasd el az Apache dokumentációt. A verziószámokat itt elhanyagoltuk, hogy bizonyosak legyünk abban, hogy az utasítások nem helytelenek. Az 'NN' helyébe a fájlok neveiből származó megfelelő értékeket kell majd behelyettesítened.
Példa 4-4. Telepítési parancsok (Apache osztott modul verzió) PHP-hez
|
A fenti lépések végrehajtása után, rendelkezel egy futó Apache 2.0-al, amely támogatja a PHP-t SAPI modulként. Természetesen sokkal több konfigurációs opció létezik mind az Apache-hoz, mind a PHP-hez. További információért használd a ./configure --help parancsot a megfelelő forrásfában. Ha szeretnél egy többszálú Apache 2.0 verziót fordítani, felül kell írnod a standard MPM-Module prefork-ot worker-el vagy perchild-al. Ehhez, a 6. sorban szereplő configure-hoz add hozzá a --with-mpm=worker vagy a --with-mpm=perchild opciót. Bizonyosodj meg a következményekről és arról, hogy tudod mit csinálsz. További információért olvasd el az Apache dokumentáció MPM-Modules című részét.
Megjegyzés: Ha szeretnél tartalom-egyeztetést (content negotiation) alkalmazni, olvasd el a kapcsolódó FAQ-t.
Megjegyzés: Ahhoz, hogy többszálú Apache verziót tudj készíteni, az operációs rendszered kell támogassa a szálakat. Ez a PHP-nak a kisérleti jellegű Zend Thread Safety (ZTS)-vel való fordítására is vonatkozik. Emiatt nem lesz használható minden kiterjesztés. Ajánlott az Apache-nak a standard prefork MPM-modullal való fordítása.
PHP 4-et Pike modulként építheted be a Caudium webszerveréhez, a PHP 3 nem támogatja ezt. A PHP 4-et az alábbi egyszerű utasításokat követve lehet telepíteni Caudium alá.
Példa 4-5. Caudium telepítési utasítások
|
Természetesen számos kiterjesztéssel együtt fordíthatod le a Caudium szerverhez is a PHP 4-t. A kiterjesztés-specifikus opciókért nézd meg a referenciaoldalakat.
Megjegyzés: Ha MySQL témogatást is szeretnél, akkor figyelj arra, hogy a normál MySQL kliens kódot használd, különben ütközések léphetnek fel, ha a Pike is rendelkezik MySQL támogatással. Ezt a MySQL telepítési könyvtárának (install directory) megadásával teheted meg: --with-mysql.
Ahhoz, hogy fhttpd modulként állítsd be a PHP-t, válaszolj "yes"-el a "Build as an fhttpd module?" kérdésre (ez a --with-fhttpd=DIR opció a configure-ban) és add meg az fhttpd könyvtárát. Ez alapbeállításban /usr/local/src/fhttpd. Ha fhttpd-t használsz, a PHP felépítése modulként jobb teljesítményt fog nyújtani, több beavatkozási lehetőséget és távoli futtatást biztosít.
Megjegyzés: Az fhttpd támogatása a PHP 4.3.0-tól megszűnt.
This section contains notes and hints specific to Sun Java System Web Server, Sun ONE Web Server, iPlanet and Netscape server installs of PHP on Sun Solaris.
From PHP 4.3.3 on you can use PHP scripts with the NSAPI module to generate custom directory listings and error pages. Additional functions for Apache compatibility are also available. For support in current webservers read the note about subrequests.
You can find more information about setting up PHP for the Netscape Enterprise Server (NES) here: http://benoit.noss.free.fr/php/install-php4.html
To build PHP with Sun JSWS/Sun ONE WS/iPlanet/Netscape webservers, enter the proper install directory for the --with-nsapi=[DIR] option. The default directory is usually /opt/netscape/suitespot/. Please also read /php-xxx-version/sapi/nsapi/nsapi-readme.txt.
Install the following packages from http://www.sunfreeware.com/ or another download site:
| autoconf-2.13 |
| automake-1.4 |
| bison-1_25-sol26-sparc-local |
| flex-2_5_4a-sol26-sparc-local |
| gcc-2_95_2-sol26-sparc-local |
| gzip-1.2.4-sol26-sparc-local |
| m4-1_4-sol26-sparc-local |
| make-3_76_1-sol26-sparc-local |
| mysql-3.23.24-beta (if you want mysql support) |
| perl-5_005_03-sol26-sparc-local |
| tar-1.13 (GNU tar) |
Make sure your path includes the proper directories PATH=.:/usr/local/bin:/usr/sbin:/usr/bin:/usr/ccs/bin and make it available to your system export PATH.
gunzip php-x.x.x.tar.gz (if you have a .gz dist, otherwise go to 4).
tar xvf php-x.x.x.tar
Change to your extracted PHP directory: cd ../php-x.x.x
For the following step, make sure /opt/netscape/suitespot/ is where your netscape server is installed. Otherwise, change to the correct path and run:
./configure --with-mysql=/usr/local/mysql \ --with-nsapi=/opt/netscape/suitespot/ \ --enable-libgcc |
Run make followed by make install.
After performing the base install and reading the appropriate readme file, you may need to perform some additional configuration steps.
Configuration Instructions for Sun/iPlanet/Netscape. Firstly you may need to add some paths to the LD_LIBRARY_PATH environment for the server to find all the shared libs. This can best done in the start script for your webserver. The start script is often located in: /path/to/server/https-servername/start. You may also need to edit the configuration files that are located in: /path/to/server/https-servername/config/.
Add the following line to mime.types (you can do that by the administration server):
type=magnus-internal/x-httpd-php exts=php |
Edit magnus.conf (for servers >= 6) or obj.conf (for servers < 6) and add the following, shlib will vary depending on your system, it will be something like /opt/netscape/suitespot/bin/libphp4.so. You should place the following lines after mime types init.
Init fn="load-modules" funcs="php4_init,php4_execute,php4_auth_trans" shlib="/opt/netscape/suitespot/bin/libphp4.so" Init fn="php4_init" LateInit="yes" errorString="Failed to initialize PHP!" [php_ini="/path/to/php.ini"] |
Configure the default object in obj.conf (for virtual server classes [version 6.0+] in their vserver.obj.conf):
<Object name="default"> . . . .#NOTE this next line should happen after all 'ObjectType' and before all 'AddLog' lines Service fn="php4_execute" type="magnus-internal/x-httpd-php" [inikey=value inikey=value ...] . . </Object> |
This is only needed if you want to configure a directory that only consists of PHP scripts (same like a cgi-bin directory):
<Object name="x-httpd-php"> ObjectType fn="force-type" type="magnus-internal/x-httpd-php" Service fn=php4_execute [inikey=value inikey=value ...] </Object> |
Setup of authentication: PHP authentication cannot be used with any other authentication. ALL AUTHENTICATION IS PASSED TO YOUR PHP SCRIPT. To configure PHP Authentication for the entire server, add the following line to your default object:
<Object name="default"> AuthTrans fn=php4_auth_trans . . . </Object> |
To use PHP Authentication on a single directory, add the following:
<Object ppath="d:\path\to\authenticated\dir\*"> AuthTrans fn=php4_auth_trans </Object> |
Megjegyzés: The stacksize that PHP uses depends on the configuration of the webserver. If you get crashes with very large PHP scripts, it is recommended to raise it with the Admin Server (in the section "MAGNUS EDITOR").
Important when writing PHP scripts is the fact that Sun JSWS/Sun ONE WS/iPlanet/Netscape is a multithreaded web server. Because of that all requests are running in the same process space (the space of the webserver itself) and this space has only one environment. If you want to get CGI variables like PATH_INFO, HTTP_HOST etc. it is not the correct way to try this in the old PHP 3.x way with getenv() or a similar way (register globals to environment, $_ENV). You would only get the environment of the running webserver without any valid CGI variables!
Megjegyzés: Why are there (invalid) CGI variables in the environment?
Answer: This is because you started the webserver process from the admin server which runs the startup script of the webserver, you wanted to start, as a CGI script (a CGI script inside of the admin server!). This is why the environment of the started webserver has some CGI environment variables in it. You can test this by starting the webserver not from the administration server. Use the command line as root user and start it manually - you will see there are no CGI-like environment variables.
Simply change your scripts to get CGI variables in the correct way for PHP 4.x by using the superglobal $_SERVER. If you have older scripts which use $HTTP_HOST, etc., you should turn on register_globals in php.ini and change the variable order too (important: remove "E" from it, because you do not need the environment here):
variables_order = "GPCS" register_globals = On |
You can use PHP to generate the error pages for "404 Not Found" or similar. Add the following line to the object in obj.conf for every error page you want to overwrite:
Error fn="php4_execute" code=XXX script="/path/to/script.php" [inikey=value inikey=value...] |
Another possibility is to generate self-made directory listings. Just create a PHP script which displays a directory listing and replace the corresponding default Service line for type="magnus-internal/directory" in obj.conf with the following:
Service fn="php4_execute" type="magnus-internal/directory" script="/path/to/script.php" [inikey=value inikey=value...] |
The NSAPI module now supports the nsapi_virtual() function (alias: virtual()) to make subrequests on the webserver and insert the result in the webpage. This function uses some undocumented features from the NSAPI library. On Unix the module automatically looks for the needed functions and uses them if available. If not, nsapi_virtual() is disabled.
Megjegyzés: But be warned: Support for nsapi_virtual() is EXPERIMENTAL!!!
Alapbeállításban a PHP CGI programként fordul le. Ez létrehoz egy parancssorból használható értelmezőt, ami CGI feldolgozásra vagy nem webbel kapcsolatos PHP programozásra is használható. Ha egy olyan webszervert futtatsz, amelyhez a PHP modul szintű támogatással rendelkezik, akkor jobb teljesítmény eléréséhez használd inkább azt a módszert. A CGI verzió azonban lehetővé teszi az Apache-ot használóknak, hogy más-más PHP oldalakat más-más user-id-kkel futtassanak.
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
As of PHP 4.3.0, some important additions have happened to PHP. A new SAPI named CLI also exists and it has the same name as the CGI binary. What is installed at {PREFIX}/bin/php depends on your configure line and this is described in detail in the manual section named Using PHP from the command line. For further details please read that section of the manual.
Ha CGI programként fordítottad le a PHP-t, tesztelheted az eredményt azzal, hogy beírod make test. Mindig jól jön, ha leteszteled, mert így rögtön észlelhetsz olyan problémákat, amik esetleg csak később bukkantak volna fel.
Ha CGI programként fordítottad le a PHP 3-at, tesztelheted a sebességét azzal, hogy beírod a make bench parancsot. Ha a be van kapcsolva, talán nem fog jól lefutni a benchmark, a megengedett 30 másodperc alatt. Ez azért van, mert a set_time_limit() nem használható safe mode-ban. Használd a max_execution_time konfigurációs beállítást, hogy megadhasd ezt az időt a szkriptjeidnek. A make bench nem veszi figyelembe a konfigurációs fájlt.
Megjegyzés: A make bench csak a PHP 3-ban érhető el.
Egyes szerver által biztosított környezeti változók nincsenek a jelenlegi CGI/1.1 specifikációban definiálva. Csak a következő változók vannak itt definiálva: AUTH_TYPE, CONTENT_LENGTH, CONTENT_TYPE, GATEWAY_INTERFACE, PATH_INFO, PATH_TRANSLATED, QUERY_STRING, REMOTE_ADDR, REMOTE_HOST, REMOTE_IDENT, REMOTE_USER, REQUEST_METHOD, SCRIPT_NAME, SERVER_NAME, SERVER_PORT, SERVER_PROTOCOL, és SERVER_SOFTWARE. Minden más 'gyártó kiterjesztésnek' minősül.
Ez a rész a PHP HP-UX rendszerre történő telepítési útmutatóját tartalmazza. (paul_mckay kukac clearwater-it pont co pont uk hozzájárulásával)
Megjegyzés: Ezek a tippek a PHP v4.0.4 és Apache v1.3.9 verziókra vonatkoznak.
Szükséged lesz a gzip-re. Töltsd le a http://hpux.connect.org.uk/ftp/hpux/Gnu/gzip-1.2.4a/gzip-1.2.4a-sd-10.20.depot.Z címről a bináris disztribúciót, tömörítsd ki, és telepítsd swinstall-al.
Szükséged lesz a GNU binutils-ra. Töltsd le a http://gatekeep.cs.utah.edu/ftp/hpux/Gnu/gcc-2.95.2/gcc-2.95.2-sd-10.20.depot.gz. címről a bináris disztribúciót, tömörítsd ki, és telepítsd swinstall-al.
Szükséged lesz a GNU binutils-ra. Töltd le a http://hpux.connect.org.uk/ftp/hpux/Gnu/binutils-2.9.1/binutils-2.9.1-sd-10.20.depot.gz. címről a bináris disztribúciót, tömörítsd ki, és telepítsd swinstall-al.
Szükséged lesz a bison-ra. Töltsd le a http://hpux.connect.org.uk/ftp/hpux/Gnu/bison-1.28/bison-1.28-sd-10.20.depot.gz, címről a bináris disztribúciót és telepítsd a fentiek szerint.
Szükséged lesz a flex-re. Ennek a forráskódját kell letöltened tudod letölteni az egyik http://www.gnu.org ükörkiszolgálóról. A non-gnu könyvtárban találod az ftp helyen. Töltsd le az állományt, tömörítsd ki gunzip-pel, majd a tar -xvf paranccsal megkapod a szükséges fájlokat. Lépj be a létrejött flex könyvtárba, és hajsd végre ./configure, make, make install parancsokat.
Ha hibaüzeneteket kapsz, feltehetően az a probléma, hogy gcc vagy egyéb eszköz nincs a PATH-ban, tehát add hozzá a PATH-hoz.
Töltsd le a PHP és Apache forráskódokat.
Alkalmazd rájuk a gunzip és a tar -xvf parancsokat. Módosítanod kell pár állományt, hogy helyesen leforduljanak.
Először a configure nevű fájl szorul némi szerkesztésre, mivel úgy tűnik nem tudja követni, hogy HP-UX gépen vagyunk. Lesz még egy jobb módszer ennek a megoldására, de addig is egy olcsó és jól működő javítás a lt_target=hpux10.20 beillesztése a configure szkript 47286-adik soránál.
A következő lépésben az Apache GuessOS fájl szorul javításra. Az apache_1.3.9/src/helpers ájlban írd át a 89. sort. Ennek jelenlegi tartalma: echo "hp${HPUXMACH}-hpux${HPUXVER}"; exit 0, erre kell átirni: echo "hp${HPUXMACH}-hp-hpux${HPUXVER}"; exit 0
Megosztott modulként nem telepíthető a PHP HP-UX rendszeren, ezért statikusan bele kell fordítanod a szerverbe. Ehhez kövesd az Apache oldalon található utasításokat.
A PHP és Apache most már sikeresen lefordult, de az Apache nem fog elindulni. Létre kell hoznod egy új felhasználót az Apache számára, például www vagy apache néven. Utána a 252-253-ik sort kell módosítanod az Apache conf/httpd.conf in állományban, tehát ehelyett a két sor helyett:
User nobody Group nogroup |
valami hasonlód lesz:
User www Group sys |
Ez azért szükséges, mivel az Apache nem futtatható a nobody nevű felhasználóval HP-UX alatt. Most már az Apache és a PHP is sikeresen kell működjön.
Ez a fejezet a PHP OpenBSD 3.6 rendszerre történő telepítéséhez tartalmaz megjegyzéseket és javaslatokat.
A PHP OpenBSD-re való telepítéséhez az ajánlott és legegyszerűbb módszer a bináris csomagok (package) használata. Az alap csomag el van választva a különböző moduloktól, és mindegyik a többitől függetlenül telepíthető és távolítható el. A szükséges fájlokat az OpenBSD CD-den vagy az FTP site-on találod.
A fő csomag, amit telepítened kell az a php4-core-4.3.8.tgz, amely az alapvető motort (és még a gettext-et és az iconv-ot) tartalmazza. Ezután következnek a modul-csomagok, mint pl. a php4-mysql-4.3.8.tgz vagy a php4-imap-4.3.8.tgz. Ezen modulok aktiválásához vagy deaktiválásához a php.ini-ben szereplő phpxs parancsot kell használnod.
Példa 4-6. Példa OpenBSD csomagtelepítésre
|
Az OpenBSD bináris csomagjairól további információt a packages(7) man oldalon találsz.
A PHP-t forráskódból is fordíthatod, a ports tree használatával, bár ez csak az OpenBSD-ben járatos felhasználóknak ajánlott. A PHP 4 port két alkönyvtárra van osztva: core és extensions. Az extensions könyvtár minden támogatott PHP modul számára alcsomagokat generál. Ha ezek közül nem szeretnél minden csomagot elkészíteni, használd a no_* FLAVOR-t. Ha pélául az imap modult szeretnéd kihagyni, a FLAVOR-t állítsd be no_imap-re.
Az Apache alapértelmezett telepítése egy chroot(2) jail-ben fut, amely megtiltja a PHP szkripteknek, hióogy elérjék a /var/www alatti fájlokat. Emiatt létre kell hoznod egy /var/www/tmp könyvtárat, ahol a PHP munkamenet fájlok létrejöhetnek, vagy használj egy másik munkamenet kezelőt. Ráadásul az adatbázis socket-eket a jail-en belülre kell helyezni vagy a localhost interfészen lehet hallgatózni. Ha hálózatkezelő függvényeket használsz, egyes fájlokat az /etc könyvtárból, mint pl. az /etc/resolv.conf és az /etc/services a /var/www/etc könyvtárba kell helyezni. Az OpenBSD PEAR csomag automatikusan a helyes chroot könyvtárakba települ, tehát itt nem szükséges semmi különleges módosítás elvégzése. Az OpenBSD Apache-ról további információt az OpenBSD FAQ-ban találasz.
A gd kiterjesztéshez tartozó OpenBSD 3.6 csomag számára telepítve kell legyen az XFree86. Ha nem akarsz néhány font szolgáltatást használni, amit az X11 megkövetel, használd inkább a php4-gd-4.3.8-no_x11.tgz csomagot.
Az OpenBSD régebbi kiadásai a FLAVORS rendszert statikusan beillesztett PHP fordítására használta. Mivel így nehezen lehet bináris csomagokat generálni, ez a módszer nem javasolt. Továbbra is használhatod a régi stabil port tree-ket, de ezt az OpenBSD csapata nem támogatja. Ha bármilyen hozzáfűznivalód van ehhez, a port jelenlegi karbantartója Anil Madhavapeddy (avsm kukac openbsd pont org).
Ez a fejezet a PHP Solaris rendszerre történő telepítéséhez tartalmaz megjegyzéseket és javaslatokat.
A Solaris telepítések gyakran nem tartalmaznak C fordítót, és a kapcsolódó eszközöket. Olvasd el ezt a FAQ-t, hogy megtudd miért szükséges ezen szoftverek GNU verzióját használni. A szükséges programok:
gcc (javasolt, más C fordító is jó lehet)
make
flex
bison
m4
autoconf
automake
perl
gzip
tar
GNU sed
Egyszerűsítheted a Solaris telepítési eljárást, ha a pkgadd-et használod a szükséges komponensek nagyrészének telepítésénél.
Ez a rész a PHP Gentoo Linux rendszerre történő telepítéséhez tartalmaz megjegyzéseket és javaslatokat.
Amellett, hogy a PHP forráskódot letöltheted és saját magad fordíthatod, a Gentoo csomag-rendszerének használata a legegyszerűbb és legtisztább módja a PHP telepítésének. Ha nem vagy jártas a Linux alatti szoftver-fordításban, ez lesz számodra a megfelelő módszer.
Ha már felépítetted a Gentoo rendszeredet, valószínűleg már használtad a Portage-t. Az Apache és PHP telepítése nem különbözik az egyéb rendszereszközök telepítésétől.
Az első döntés, amit meg kell hoznod, hogy Apache 1.3.x-t vagy Apache 2.x-t akarsz telepíteni. Mindamellett, hogy mindkettő használható PHP-vel, az alábbi lépések Apache 1.3.x-t fognak használni. Egy másik dolog, amit figyelembe kell venni az, hogy a Portage fád naprakész-e. Ha már rég frissíteted, mindenekelőtt érdemes futtatnod az emerge sync parancsot. Így az Apache és a PHP legfrisseb verzióit fogod használni.
Ha most minden a helyén van, használd a következő példát az Apache és a PHP telepítéséhez:
Példa 4-7. Példa PHP telepítésére Gentoo rendszeren Apache 1.3-hoz
|
Az emerge-ről a kiváló Portage kézikönyvben olvashatsz, amit a Gentoo weboldalán találsz.
Ha Apache 2-t szeretnél használni, használd egyszerűen az emerge apache utasítást a példában.
Az utolsó részben a PHP aktívált modulok nélkül volt emerge-elve. Amikor ez a leírás készült, az egyetlen alapértelmezésben aktivált modul az XML, amely szüksége a PEAR-hez. Ez valószínű nem az amit szeretnél, és hamarosán rájössz, hogy több aktivált modulra van szükséged, mint pl. MySQL, gettext, GD, stb.
Amikor a PHP-t saját magad fordítod, a configure parancs során kell aktiválnod modulokat. A Gentoo esetén egyszerűen megadhatsz USE jelzőket, amelyek automatikusan át lesznek adva a configure szkriptnek. Próbáld ki az alábbi parancsot, hogy lásd milyen USE jelzők adhatók meg az emerge-nek:
Példa 4-8. Az érvényes USE jelzők listájának lekérése
|
Amint a fenti kimenetből észreveheted, PHP sok USE jelzőt figyelembe vesz. Nézd meg őket közelebbről és válaszd ki amire szükséged van. Ha kiválasztasz egy jelzőt, de nem rendelkezel alkalmas könyvtárakkal, a Portage lefordítja azokat. Jó ötlet az emerge -pv újbóli használata, hogy lásd, mit fog a Portage fordítani azért, hogy használhasd a USE jelzőidet. Ha például nincs az X telepítve, és hasznnálod USE jelzőként, a Portage a PHP előtt lefordítja az X-et, ami néhány órába telhet.
Ha a PHP-t szeretnéd MySQL, cURL és GD támogatással fordítani, a parancs így fog kinézni:
Mint ahogy a fenti példa is muatja, ne felejtsd el a php-t és a mod_php-t emerge-elni. A php a parancssori változatért felelős, a mod_php pedig az Apache modul verziójáért.
Ha PHP szkript kimenete helyett a forráskódot kapod meg, valószínűleg megfeledkeztél az /etc/conf.d/apache fájl szerkesztéséről. Az Apache-t a -D PHP4 jelzővel kell elindítani. Ha a jelző jelen van, látnod kell a ps ax | grep apache parancs kimenetében, miközben az Apache fut.
Beillesztési problémák miatt, előfordulhat, hogy nem telepíthetsz több PHP verziót. Ebben az esetben a unmerge-elned kell a régi verziót a emerge unmerge mod_php-<régi verzió> paranccsal.
Ha nem tudod emerge-elni a PHP-t a Java miatt, próbáld meg úgy, hogy a -* karaktereket beilleszted a USE jelzők elé, mint ahogy a fenti példában látható.
Ha problémád akad az Apache és a PHP konfigurálásával, bármikor kereshetsz a Gentoo fórumokban. Próbálj meg az "Apache PHP" kulcsszavakkal keresni.
Ez a fejezet a PHP Mac OS X rendszerre történő telepítésének dokumentációját tartalmazza. A Mac OS X rendszernek két némileg eltérő változata van, a kliens és szerver. Kézikönyvünk mindkét rendszerhez tartalmaz telepítési útmutatót. A PHP nem futtatható a MacOS 9 vagy korábbi verziókon.
Rendelkezésre áll néhány előre-csomagolt és előre-fordított PHP változat a Mac OS X rendszerekre. Ez sokat tud segíteni egy általános telepítés elvégzésében, de ha más funkciókra is vágysz (például biztonságos szerver funkciókra, vagy más adatbázis támogatására), előfordulhat, hogy mégis magadnak kell fordítanod a PHP-t és/vagy a szervert. Ha nem vagy tapasztalt az önálló fordításban, megéri utánanézni, hogy elkészítette-e már valaki más azt a csomagot, ami a kívánt funkciókkal rendelkezik.
Töltsd le az Apache és PHP legfrissebb változatait
Tömörítsd ki ezeket, és futtasd a configure programot az Apache-ra:
./configure --exec-prefix=/usr \ --localstatedir=/var \ --mandir=/usr/share/man \ --libexecdir=/System/Library/Apache/Modules \ --iconsdir=/System/Library/Apache/Icons \ --includedir=/System/Library/Frameworks/Apache.framework/Versions/1.3/Headers \ --enable-shared=max \ --enable-module=most \ --target=apache |
Ha szeretnéd, hogy a fordító végezzen optimizációt, add hozzá a következő sort is:
setenv OPTIM=-O2 |
Lépj be a PHP 4 forrás könyvtárába, és futtasd a configure programot:
./configure --prefix=/usr \
--sysconfdir=/etc \
--localstatedir=/var \
--mandir=/usr/share/man \
--with-xml \
--with-apache=/src/apache_1.3.12 |
Add ki a make, majd a make install parancsokat. Ez létre fog hozni egy könyvtárat az Apache forráskönyvtárában az src/modules/php4 alatt.
Most újra futtatnod kell a configure-t az Apache-ra, hogy beépítsd a PHP 4-et:
./configure --exec-prefix=/usr \ --localstatedir=/var \ --mandir=/usr/share/man \ --libexecdir=/System/Library/Apache/Modules \ --iconsdir=/System/Library/Apache/Icons \ --includedir=/System/Library/Frameworks/Apache.framework/Versions/1.3/Headers \ --enable-shared=max \ --enable-module=most \ --target=apache \ --activate-module=src/modules/php4/libphp4.a |
Másold, és nevezd át a php.ini-dist állományt a bin könyvtárba a PHP 4 forráskönyvtárból: cp php.ini-dist /usr/local/bin/php.ini vagy (ha nincs local könyvtárad) cp php.ini-dist /usr/bin/php.ini.
A következő útmutató segítségedre lesz abban, hogy a PHP-t modulként telepítsd a MacOS X-ben jelenlévő Apache webszerverhez. Ez a verzió támogatja a MySQL és a PostgreSQL adatbáziskezelő rendszereket. Ezeket a tippeket Marc Liyanage adta szívesen közre..
| Figyelem |
Légy körültekintő az alábbiakban, mert tönkreteheted az Apache szerveredet! |
Telepítéshez az alábbiakat kell tenni:
Nyiss egy terminál ablakot.
Írd be: wget http://www.diax.ch/users/liyanage/software/macosx/libphp4.so.gz, és várd meg, amíg letöltődik.
Írd be: gunzip libphp4.so.gz.
Írd be: sudo apxs -i -a -n php4 libphp4.so
Most írd be, hogy: sudo open -a TextEdit /etc/httpd/httpd.conf. TextEdit megnyitja a webszerver konfigurációs fájlját. Keresd meg a következő két sort a fájl vége felé (használd a Find parancsot):
#AddType application/x-httpd-php .php #AddType application/x-httpd-php-source .phps |
Végül írd be: sudo apachectl graceful hogy újrainduljon a webszerver.
Mostantól a PHP-nak futni kell. Ezt ellenőrizheted, ha a Sites könyvtáradba bemásolod a test.php fájlt, amiben nincs más csak ez a sor: <?php phpinfo() ?>.
Most nyisd meg a 127.0.0.1/~a_sajat_userneved/test.php címen levő oldalt a webböngésződben. A PHP modul információs táblázatait kell látnod ezen az oldalon.
Ez a fejezet a Windows 98/Me és a Windows NT/2000/XP/2003 rendszerekre történő telepítésekre vonatkozik. A PHP nem működik 16 bites környezetben mint például a Windows 3.1. Bizonyos esetekben a támogatott Windows környezetekre Win32 néven hivatkozunk. A PHP a 4.3.0 verziótól kezdődően nem támogatja a Windows 95-öt.
A PHP Windows-ra telepítésének két fő módja van: kézi telepítővarázslóval történő telepítés.
Ha van Microsoft Visual Studio telepítve a rendszereden, akkor a PHP-t az eredeti forrásból is lefordíthatod.
Amint sikerült a PHP-t telepítened a Windows-odra, különböző kiterjesztéseket is betölthetsz további funkcionalitások eléréséhez.
| Figyelem |
Számos telepítő-csomag található az Interneten, de egyikük sincs jóváhagyva a PHP.net által, mivel úgy gondoljuk, hogy a kézi telepítés a legjobb választás, hogy a rendszered biztonságos és optimális legyen. |
A Windows PHP telepítőprogram letölthető a http://www.php.net/downloads.php címről, ez a PHP CGI változatát telepíti is beállítja az IIS, PWS és Xitami szervereket is. A telepítő nem tartalmaz semmilyen külső PHP kiterjesztést (php_*.dll), ezért csak a Windows zip csomagban és a PECL-ben találod meg.
Megjegyzés: Bár a Windows telepítő egyszerű módszer a PHP működésre bírásának, sok oldalról korlátozva van, mert például a kiterjesztések automatikus telepítése nem történik meg. A telepítő használata nem a megefelelő módszer a PHP telepítésére.
Először telepítsd a választott HTTP (web-) szervert a gépedre, és ellenőrizd, hogy jól működik-e.
Futtassd a telepítő exe fájlt, és kövesd a varázsló által adott utasításokat. Kétféle telepítés közül választhatsz - a standard telepítés ésszerű alapbeállításokat ad, az advanced kérdéseket tesz fel (amelyekre tudni kell válaszolni :).
A telepítés varázslója elég információt gyűjt ahhoz, hogy elvégezhesse a php.ini fájl beállítását és konfiguráljon számos webszervert a PHP számára. Az egyik webszerver, amit a PHP telepítő nem konfigurál, az Apache, ezért kézzel kell konfigurálnod.
Mikor a telepítés befejeződött, a varázsló informál arról, hogy szükséges-e a rendszer, ill. a szerver újraindítása, vagy rögtön elkezdheted a munkát a PHP-vel.
| Figyelem |
Légy tekintettel arra, hogy a PHP ezen telepítési módja nem biztonságos. Ha biztonságos PHP-ra vágysz, akkor jobban teszed, ha a kézikönyv további fejezeteit is elolvasod, és minden beállítást körültekintően elvégzel. Ez az automatikus telepítő egy azonnal használható PHP-t varázsol a gépedre, de nem online szerverekre szánták. |
Ez a fejezet segít a PHP kézi telepítésében és konfigurálásában Microsoft Windows-os webszerverek számára. Ehhez a zippelt bináris disztribuciót kell letölteni a http://www.php.net/downloads.php címről.
A Microsoft Windows-hoz számos telepítőkészlet létezik, és mi is terjesztünk egy PHP telepítőt, mi mégis azt javasoljuk, hogy szándd rá az időt, hogy magad telepítsd a PHP-t, mivel így jobban megérted a rendszert és lehetővé teszi számodra, hogy szükség esetén a PHP kiterjesztések telepítését könnyedén evégezd.
Egy előző PHP verzió frissítése: A kéziköny korábbi kiadásai azt javasolták, hogy a különböző ini és DLL fájlokat a rendszerkönyvtárba (pl. C:\WINDOWS) tedd, és bár ez egyszerűsíti telepítést, a frissítést megnehezíti. Azt tanácsoljuk, távolítsd el ezeket a fájlokat, (mint pl. a Windows rendszermappában található php.ini és a PHP-vel kapcsolatoss DLL-ek) mielőtt elkezdenéd az új PHP telepítését. Ne felejtsd el biztonsági másolatot készíteni ezekről arra az esetre, ha tönkretennéd a rendszert. A régi php.ini is hasznos lehet az új PHP beállításánál. Hamarosan megtanulod, hogy előnyösebb a PHP-vel kapcsolatos fájlokat egy könyvtárban tartani, és ezt a könyvtárat a PATH-ba beírni.
MDAC követelmények: Ha Windows 98/NT4-et használsz, töltsd le a Microsoft Data Access Components (MDAC) rendszeredhez tartozó legfirssebb verzióját. Az MDAC letölthető a http://msdn.microsoft.com/data/ címen. Ez azért követelmény, mert a terjesztett Windows binárisokba bele van építve az ODBC támogatás.
Az alábbi lépéseket minden rendszeren végre kell hajtani, a szerver specifikus lépések elvégzése előtt:
Tömörítsd ki a disztribúciós állományt egy általad választott könyvtárba. Ha PHP 4-et telepítesz, a C:\ könyvtárba tömörítsd ki. A zip fájl egy php-4.3.7-Win32-höz hasonló könyvtárba tömörítődik ki. Ha PHP 5-el van dolgod, akkor a C:\php-be tömörítsd ki, mivel ebben az esetben más a zip fájl felépítése. Más útvanalat is választhatsz, de ne tartalmazzon szóközt. (mint pl. a C:\Program Files\PHP) mivel egyes webszerverek összeomlanak, ha így teszel.
A PHP 4-es és 5-ös verziójának kizippelt könyvtárstruktúrája különbözik:
Példa 6-1. A PHP 4 csomag felépítés
|
Or:
Példa 6-2. A PHP 5 csomag felépítése
|
Figyelj a különbségekre és az egyezőségekre. A PHP 4 és PHP 5 is tartalmaz CGI és CLI programot, és szerver modulokat, de más könyvtárakban vannak és/vagy más nevük van. Míg a PHP 4 szervermoduljai a sapi könyvtárban van, a PHP 5-nek nincs ilyen könyvtára, és a PHP könyvtár gyökerében találhatóak meg. A PHP 5 kiterjesztések segéd-DLL-jei szintén nem külön könyvtárban vannak.
Megjegyzés: PHP 4 esetén minden fájlt, ami a dll és a sapi könyvtárban van, a főkönyvtárba kell helyezned (pl. C:\php).
Itt egy lista a PHP 4-el és PHP 5-el terjesztett szerver modulokról:
sapi/php4activescript.dll (php5activescript.dll) - ActiveScript motor, amely lehetővé teszi PHP beépítése Windows-os alkalmazásokba.
sapi/php4apache.dll (php5apache.dll) - Apache 1.3.x modul.
sapi/php4apache2.dll (php5apache2.dll) - Apache 2.0.x modul.
sapi/php4isapi.dll (php5isapi.dll) - ISAPI modul ISAPI webszerverekhez mint pl. az IIS 4.0/PWS 4.0 vagy újabb.
sapi/php4nsapi.dll (php5nsapi.dll) - Sun/iPlanet/Netscape szervermodul.
sapi/php4pi3web.dll (nincs megefelelője PHP 5-ben) - Pi3Web szervermodul.
A szervermodulok jelentősen nagyobb hatékonyságot és további funkcionalitást biztosítanak a CGI binárisokhoz képest. A CLI verzió arra volt tervezve, hogy a PHP-t paranccsori programozásra használhasd. A CLI-ről a PHP parancssori alkalmazásáról szóló fejezetben tudhatsz meg többet.
| Figyelem |
A SAPI modulok jelentősen tökeletesítve voltak a 4.1-es kiadásban, viszont a régebbi rendszerekben előfordulhat szerverhiba vagy egyéb szervermodulok hibája, mint pl. ASP. |
A CGI és CLI binárisoknak szintén szükségük van a php4ts.dll (php5ts.dll) szervermodulra. Bizonyosodj meg róla, hogy ez a fájl elérhető a feltelepített PHP-dben. A DLL keresésének sorrendje:
Az a könyvtár, ahonnan a php.exe meg lett hívva, vagy abban az esetben, ha SAPI modulként használod, a webszerver könyvtára (pl. C:\Program Files\Apache Group\Apache2\bin).
Bármilyen könyvtár, amely a Windows PATH környezeti változóban szerepel.
A php4ts.dll / php5ts.dll fájlok elérhetővé tételéhez három változat közül kell választanod: másold be a Window rendszerkönyvtárába, másold be a webszerver könyvtárába, vagy a PHP könyvtáradat (C:\php) add hozzá a PATH-hoz. A könnyebb kezelhetőség érdekében, mi az utóbbi változatot használjuk, mert így a jövőben könnyebb lesz frissíteni a PHP-t. A PHP könyvtár PATH-hoz adásáról a megfelelő FAQ-ban olvashatsz.
A következő lépés egy érvényes könfigurációs fájl (php.ini) létrehozása. Két ini fájl található meg a terjesztett zip fájlban, a php.ini-dist és a php.ini-recommended. Azt tanácsoljuk, hogy használd a php.ini-recommended fájlt, mert ebben a fájlban a beállításokat a hatékonyság és biztonság növelése érdekében állítottuk be. Ezt a jól dokumentált fájlt figyelmesen olvasd, mert a php.ini-dist fájlhoz viszonyított változások erőteljesen befolyásolhatják a PHP működését. Néhány példa: a display_errors értéke off valamint a magic_quotes_gpc értéke off. Azon felül, hogy ezeket elolvasod, tanulmányozd az ini beállításokat és minden opciót magad állíts be. Ha a legnagyobb biztonságot szeretnéd elérni, ezt kell tenned, bár a PHP egész jól működik az alapbeállításokkal is. Másold be a kívánt ini fájlt egy olyan könyvtárba, ahol a PHP képes azt megtalálni, és persze nevezd át php.ini-re. A PHP a php.ini-t a A konfigurációs állomány 9 fejezet részben ismertett könyvtárakban keresi.
Ha Apache 2-t használsz, a legegyszerűbb módszer a PHPIniDir direktíva használata. (olvasd el a Telepítés Apache 2 rendszerre című oldalt), egyébként pedig a PHPRC környezeti változó a legjobb változás. Ez a folyamat az alábbi FAQ bejegyzésben van leírva.
Megjegyzés: Ha NTFS-t használsz Windows NT, 2000, XP vagy 2003-on, bizonyosodj meg arról, hogy a webszervert futtató felhasználónak van joga a php.ini olvasásához (pl. tedd olvashatóvá mindenki számára).
A következő lépések elhagyhatóak:
Szerkeszd az új php.ini fájlodat. Ha tervezed, az OmniHTTPd használatát, ne kövesd a következő lépést. Állítsd be a doc_root-ot úgy, hogy a webszervered document_root-jára mutasson. Például:
Válaszd ki azokat a kiterjeszéseket, amelyeket a PHP indulásakor szeretnél betölteni. Olvasd el a Kiterjesztések telepítése Windows-on című részt, hogy megtudd, hogy állíts be egyet, és hogy mely kiterjesztések vannak beépítve. Ajánlatos előbb az újonnan telepített PHP-t kipróbálni mielőtt még a php.ini-ben aktiválnád a kiterjesztéseket.
PWS és IIS szervereken beállíthatod a browscap konfigurációs beállítást, hogy a Windows 9x/Me esetén a c:\windows\system\inetsrv\browscap.ini, NT/2000 esetén a c:\winnt\system32\inetsrv\browscap.ini XP esetén pedig a c:\windows\system32\inetsrv\browscap.ini fájlra mutasson. Egy naprakész browscap.ini megszezéséért olvasd el a következő FAQ-t.
A PHP most telepítve van a rendszereden. A következő lépésbe válassz egy webszervert, és vedd rá a PHP futtatására. Válassz egy webszervert a tartalomjegyzékből.
This section contains notes specific to the ActiveScript installation.
ActiveScript is a windows only SAPI that enables you to use PHP script in any ActiveScript compliant host, like Windows Script Host, ASP/ASP.NET, Windows Script Components or Microsoft Scriptlet control.
As of PHP 5.0.1, ActiveScript has been moved to the PECL repository. Ezen PECL kiterjesztés DLL állományát letöltheted a PHP Letöltések, vagy a http://snaps.php.net/ címről.
Megjegyzés: You should read the manual installation steps first!
After installing PHP, you should download the ActiveScript DLL (php5activescript.dll) and place it in the main PHP folder (e.g. C:\php).
After having all the files needed, you must register the DLL on your system. To achieve this, open a Command Prompt window (located in the Start Menu). Then go to your PHP directory by typing something like cd C:\php. To register the DLL just type regsvr32 php5activescript.dll.
To test if ActiveScript is working, create a new file, named test.wsf (the extension is very important) and type:
<job id="test">
<script language="PHPScript">
$WScript->Echo("Hello World!");
</script>
</job> |
Megjegyzés: In PHP 4, the engine was named 'ActivePHP', so if you are using PHP 4, you should replace 'PHPScript' with 'ActivePHP' in the above example.
Megjegyzés: ActiveScript doesn't use the default php.ini file. Instead, it will look only in the same directory as the .exe that caused it to load. You should create php-activescript.ini and place it in that folder, if you wish to load extensions, etc.
Ez a fejezet az IIS (Microsoft Internet Information Server) szerverekre vonatkozó PHP telepítési útmutatókat tartalmazza.
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
Előszöris olvasd el a kézi telepítés lépéseit. Ne hagyd ki ezt a részt mert fontos információkat tartalmaz a PHP Windows-ra való telepítésével kapcsolatban.
Ha CGI módot használsz, a php.ini-ben a cgi.force_redirect PHP direktívát 0-ra kell állítanod. A cgi.force_redirect-el kapcsolatos FAQ-ban fontos információkat találsz. Szintén CGI mód esetén a cgi.redirect_status_env direktívát érdemes beállítani. Amikor direktívákat szeretnál használni vigyázz, hogy ezek a direktívák a php.ini-ben ne legyenek kikommentezve.
A PHP 4 CGI neve php.exe, míg PHP 5 esetén php-cgi.exe. A PHP 5 esetén, a php.exe CLI, és nem CGI.
A Windows PATH környezeti változójához add hozzá a PHP könyvtárat, így a PHP DLL fájljai, futtatható állományai és a php.ini a PHP könyvtárában maradhat, anélkül, hogy a Windows rendszerkönyvtárat fel kellene forgatni. További információért lásd a PATH beállításáról szóló GyIK-ot.
Az IIS felhasználó (általában IUSR_MACHINENAME) jogosult kell legyen bizonyos fájlok és könyvtárak olvasására, mint például a php.ini, docroot, és a munkamenet tmp könyvtára.
Figyelj oda, hogy a php.ini-ben az extension_dir és a doc_root PHP direktívák helyesen legyenek beállítva. Ezen direktívák értéke függ a rendszertől, ahova a PHP-t telepíted. PHP 4-ben az extension_dir extensions, míg PHP 5 esetén ez ext. PHP 5 esetén az extensions_dir értéke lehet például "c:\php\ext", az IIS doc_root értéke pedig "c:\Inetpub\wwwroot".
A PHP kiterjesztések DLL állományai, mint például a php_mysql.dll és a php_curl.dll, a letöltött zip csomagban találhatók meg (nem a PHP telepítőben). PHP 5 esetén sok kiterjesztés a a PECL része, ezért a "PECL modulok gyűjteményéből" tölthetőek le, ilyenek például a php_zip.dll és php_ssh2.dll állományok. A PHP fájlokat innen töltheted le.
Amikor megadod a futtatható állományt, jó ha a 'check that file exists' négyzet be van jelölve. Egy kis teljesítménycsökkenéssel az IIS (PWS) meg fogja vizsgálni, hogy a szkript fájl létezik-e, mielőtt meghívja a PHP-t, így a webszerver értelmes 404-es hibákat fog adni, ahelyett, hogy CGI hibákat dobna arról hogy a PHP-től nem kapott kimenetet.
A PHP kétféle módon telepíthető, CGI binárisként és ISAPI modulként. Mindkét esetben el kell indítanod a Microsoft Management Console programot (lehet 'Internet Services Manager', a Windows NT 4.0 Option Pack ágban vagy a Control Panel=>Administrative Tools-ban Windows 2000/XP alatt). Majd jobbklikk a Web szerver csomópontra (ami valószínűleg 'Default Web Server'-ként jelenik meg), majd válaszd ki a 'Properties' menüpontot.
Ha a CGI binárist szeretnéd használni, akkor:
A 'Home Directory', 'Virtual Directory', vagy 'Directory' alatt végezd el a következőket:
A Execute Permissions-t (Futtatási jogosultság) állítsd 'Scipts only'-ra ('Csak szkriptek')
Klikkelj a 'Configuration' gombra, majd válaszd ki az Application Mappings fület. Kattints az Add-ra, majd az Executable path-ot állítsd be a megfelelő CGI fájlra. Egy példa PHP 5 esetén: C:\php\php-cgi.exe. Kiterjesztésként .php -t adj meg. A 'Method exclusions' mezőt hagyd üresen, és jelüld be a 'Script engine' négyzetet. Ezután nyomj OK-t néhányszor.
Állíts be megfelelő védelmet. Ez az Internet Service Manager-ben megvan, és ha az NT szervered NTFS fájlrendszert használ, adj futtatási jogot I_USR_ számára ara a könyvtárra ahol a php.exe / php-cgi.exe található.
Ha ISAPI modulként akarod használni, akkor:
Ha nem szeretnél PHP segítségével HTTP Autentikáviót végezni, hagyd ki ezt a lépést. Az ISAPI Filters alatt, hozz létre egy új ISAPI filtert. A filter neve legyen PHP, majd add meg a php4isapi.dll / php5isapi.dll fájl útvonalát.
A 'Home Directory', 'Virtual Directory', vagy 'Directory' alatt végezd el a következőket:
A Execute Permissions-t (Futtatási jogosultság) állítsd 'Scipts only'-ra ('Csak szkriptek')
Klikkelj a 'Configuration' gombra, majd válaszd ki az Application Mappings fület. Kattints az Add-ra, majd az Executable path-ot állítsd be a megfelelő ISAPI DLL-re. Egy példa PHP 5 esetén: C:\php\php5isapi.dll. Kiterjesztésként .php -t adj meg. A 'Method exclusions' mezőt hagyd üresen, és jelüld be a 'Script engine' négyzetet. Ezután nyomj OK-t néhányszor.
Állítsd le teljesen az IIS-t (NET STOP iisadmin)
Indítsd el újra az IIS-t (NET START w3svc)
IIS 6 esetén (2003 Server), nyisd meg az IIS Manager-t, menj a Web Service Extensions-be, válaszd az "Add a new Web service extension"-t, írj be egy nevet, mint például PHP, válaszd az Add gombot és keresd meg vagy az ISAPI fájlt (php4isapi.dll vagy php5isapi.dll) vagy pedig a CGI-t (php.exe vagy php-cgi.exe), majd jelöld be a "Set extension status to Allowed"-et, végül OK.
Ahhoz, hogy az index.php-t használja alapértelmezett oldalként, a következőket kell tenned: A Documents fülön, válaszd az Add gombot. Írd be: index.php majd OK. Állítsd a sorrendet a Move Up és Move Down gombokkal. Ez hasonló az Apache DirectoryIndex beállításával.
A fenti lépéseket minden olyan kiterjesztésre hajtsd végre, amelyet a PHP szkriptekhez szeretnél rendelni. A .php a legeltejedtebb, bár egyes régi programok esetén szükséges lehet a .php3.
Ha egy idő után 100%-os CPU kihasználtságot észlelsz, kapcsold ki a Cache ISAPI Application IIS beállítást.
A PWS 4 Nem támogatja az ISAPI-t, ezért csak a PHP CGI mód használható.
Szerkeszd át a csatolt pws-php4cgi.reg / pws-php5cgi.reg fájlt (PHP 4 esetén a SAPI könyvtárban, PHP 5 esetén pedig a főkönyvtárban), hogy abban a php.exe / php-cgi.exe fájlra való hivatkozás a telepítésnek megfelelő legyen. A visszaperjeleket meg kell előzze egy maásik visszaperjel, pl.: [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\w3svc\parameters\Script Map] ".php"="c:\\php\\php.exe" (PHP 5 esetén C:\\php\\php-cgi.exe). Most olvaszd be a registry fájlt a rendszerbe, például klikkelj rá kétszer.
A PWS Manager-ben, egy jobbegérgomb kattintás arra a könyvtárra, amelyhez PHP támogatást szeretnél rendelni, és válaszd ki a Properties menüpontot. Jelöld be az 'Execute' négyzetet, és nyomd meg az OK-t.
Ezen szervereken a konfigurálás a disztribúciókban szereplő REG fájlok segítségével javasolt (PHP 4 esetén a SAPI könyvtáran szereplő pws-php4cgi.reg, PHP 5 esetén pedig a főkönyvtárban szereplő pws-php5cgi.reg). Szerkeszd ezt a fájlt, bizonyosodj meg arról, hogy a kiterjesztések és a PHP könyvtár megfelel a konfigurációnak, vagy kövesd az alábbi lépéseket, hogy elkészítsd ezt saját kezűleg.
| Figyelem |
Az alábbi lépések a windows registry-ben való közvetlen szerkesztést igénylik. Egyetlen hiba használhatatlanná teheti a rendszeredet! Mindenképpen készíts egy biztonsági másolatot, mielőtt bármi mást tennél. A PHP fejlesztői csapata nem tehető felelőssé, ha kárt teszel a registry-ben! |
Indítsd el a Regedit-et.
Keresd meg a HKEY_LOCAL_MACHINE /System /CurrentControlSet /Services /W3Svc /Parameters /ScriptMap kulcsot.
Az Edit menüben válaszd ki a New->String Value menüpontot.
Írd be a fájl kiterjesztést, amit használni szeretnél, pl. .php
Klikkelj kétszer az új értékre és írd be a php.exe elérési útját, PHP 4 esetén például C:\php\php.exe "%s" %s, PHP 5 esetén pedig C:\php\php-cgi.exe "%s" %s.
Ismételd ezeket a lépéseket az összes kiterjesztésre, amit PHP szkripthez szeretnél használni.
A következő lépések nem befolyásolják a web szerver üzembehelyezését, és csak akkor van rá szükség, ha a php szkriptjeidet parancssorból is szeretnéd futtatni (pl. c:\myscripts\test.php) - vagy a fájlkezelőben duplakattintásra elindítani azokat. Ugord át ezeket a lépéseket, ha azt akarod, hogy duplakattintásra inkább a szövegszerkesztődbe töltődjenek be a PHP szkriptek.
Keresd meg a: HKEY_CLASSES_ROOT kulcsot.
Az Edit menüben válaszd a New->Key menüpontot.
Nevezd el az új kulcsot az előzőekben megadott kiterjesztés nevére, pl. .php
Válaszd ki az új kulcsot, aztán a jobb oldalon kattints kétszer a "default value" soron, és írd be, hogy phpfile.
Ismételd az utóbbi lépést az összes kiterjesztésre, amit az előző részben beállítottál.
Most hozz létre ismét egy új kulcsot (New->Key) a HKEY_CLASSES_ROOT alatt, és nevezd el phpfile-ra.
Válaszd ki az új phpfile kulcsot, aztán a jobb oldalon kattints kétszer a "default value" sorra, és írd be, hogy PHP Script.
Kattints jobb gombbal a phpfile kulcsra és válaszd ki a New->Key menüpontot. Nevezd az új kulcsot Shell-nek.
Kattints jobb gombbal a Shell kulcsra és válaszd ki a New->Key menüpontot. Nevezd az új kulcsot open-nek.
Kattints jobb gombbal az open kulcsra és válaszd ki a New->Key menüpontot. Nevezd az új kulcsot command-nak.
Válaszd ki az új command kulcsot, aztán a jobb oldalon kattints kétszer a "default value" soron, és írd be a php.exe elérési útját, pl. c:\php\php.exe -q %1. Ne felejtsd el a %1-et!
Lépj ki a Regedit-ből.
Ha Windows alatt PWS szervert használsz, indítsd újra a gépet, hogy újratöltse a rendszer a registry-t.
PWS és IIS 3 használók így már rendelkeznek egy teljesen funkcionális rendszerrel. IIS 3 használóknak ajánlható Steven Genusa ötletes script map konfiguráló eszköze.
Ez a rész a PHP Microsoft Windows rendszeren az Apache 1.3.x szerverhez történő telepítéséhez tartalmaz információkat. Az Apache 2-re vonatkozó információkat külön oldalon találod.
Megjegyzés: Mindenekelőtt olvasd el a kézi telepítés lépéseit!
A PHP Apache 1.3.x-hez történő telepítésére Windows alatt két módszer létezik. Az egyik a CGI bináris használata (PHP 4 esetén php.exe, PHP 5 esetén pedig php-cgi.exe), a másik az Apache modul DLL. Mindkét esetben kell szerkesztened a httpd.conf fájlt, hogy tudasd az Apache-al, hogy használja a PHP-t, ezután újra kell indítanod a szervert.
Érdemes itt megjegyeznünk, hogy a SAPI modul Windows-os változata sokkal stabilabb lett, javasoljuk inkább ennek a használatát, mintsem a CGI binárisét, mivel az előbbi sokkal átlátszóbb és biztonságosabb.
Bár létezik néhány variáció a PHP bekonfigurálására Apache-on, ezek elég egyszerűek ahhoz, hogy az újdonsültek is használhassák. További konfigurációs direktívákért lásd az Apache dokumentációt.
Miután a konfigurációs fájlt módosítottad, ne felejtsd el úraindítani a szervert, például a NET STOP APACHE, majd a NET START APACHE parancsokkal, ha az Apache-t Windows kiszolgálóként futtatod, vagy használd a megszokott ikonokat.
Megjegyzés: Ne feledd, hogy amennyiben elérési ótvonalakat adsz meg az Apache konfigurációs állományaiban Windows alatt, minden hanyattperjelet (\) át kell alakítanod sima perjellé. Tehát a c:\directory\file.ext elérési utat így kell megadnod: c:/directory/file.ext!
A következő sorokat kell hozzáadnod az Apache httpd.conf fájlhoz:
Példa 6-3. PHP telepítése Apache 1.3.x modulként Feltételezzük, hogy a PHP a c:\php könyvtárba van telepítve. Ha nem így van, akkor írd át az útvonalakat. PHP 4 esetén:
PHP 5 esetén:
Mindkettő esetén:
|
Ha a PHP comagot a C:\php\ könyvárba zippelted ki, mint ahogy a kézi telepítés lépéseit leíró részben írtuk, a CGI bináris konfigurálásához a következő sorokat kell beszúrnod:
Példa 6-4. A PHP és az Apache 1.3.x CGI-ként
|
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
Ha szeretnéd a PHP forrásokat kiszínezve megjeleníteni, modul verzió esetén nincs erre megfelő módszer. Ha a CGI telepítést választottad, használhatod a highlight_file() függvényt. Készíts egy PHP szkriptet, és írd bele ezt: <?php highlight_file('egy_php_script.php'); ?>.
This section contains notes and hints specific to Apache 2.0.x installs of PHP on Microsoft Windows systems. We also have instructions and notes for Apache 1.3.x users on a separate page.
Megjegyzés: You should read the manual installation steps first!
Apache 2.2.x Support: Users of Apache 2.2.x may use the documentation below except the appropriate DLL file is named php5apache2_2.dll and it only exists as of PHP 5.2.0. See also http://snaps.php.net/
| Figyelem |
Nem ajánljuk az Apache2 threaded MPM-jének alkalmazását éles környezetben. Ehelyett a prefork MPM használata, vagy az Apache 1.3-as változatának használata javallott. Ha kíváncsi vagy a miértekre, olvasd el a kapcsolódó FAQ bejegyzést: Apache2 with a threaded MPM! |
You are highly encouraged to take a look at the Apache Documentation to get a basic understanding of the Apache 2.0.x Server. Also consider to read the Windows specific notes for Apache 2.0.x before reading on here.
PHP és Apache 2.0.x kompatibilitása: A PHP alábbi verziói biztosan működnek az Apache 2.0.x legújabb verziójával:
A PHP ezen verziói kompatibilisek az Apache 2.0.40-ás és későbbi verzióival.
- PHP 4.3.0 vagy későbbi, elérhető itt: http://www.php.net/downloads.php.
- a legfrisseb stabil fejlesztői verzió. A forráskód letöltése: http://snaps.php.net/php4-latest.tar.gz, Windows binárisok letöltése: http://snaps.php.net/win32/php4-win32-latest.zip.
- prerelease verzió, letölthető itt: http://qa.php.net/.
- bármikor letöltheted a PHP-t anonymous CVS-el.
Az Apache 2.0 SAPI-támogatása a PHP 4.2.0-ás verziójával kezdődött. A PHP 4.2.3 az Apache 2.0.39-el működik, ne használj más Apache verziót vele. Az ajánlott konfiguráció: PHP 4.3.0 vagy frissebb, és az Apache2 legfrissebb verziója.
A PHP minden említett verziója továbbra is működik az Apache 1.3.x verziójával.
| Figyelem |
Apache 2.0.x is designed to run on Windows NT 4.0, Windows 2000 or Windows XP. At this time, support for Windows 9x is incomplete. Apache 2.0.x is not expected to work on those platforms at this time. |
Download the most recent version of Apache 2.0.x and a fitting PHP version. Follow the Manual Installation Steps and come back to go on with the integration of PHP and Apache.
There are two ways to set up PHP to work with Apache 2.0.x on Windows. One is to use the CGI binary the other is to use the Apache module DLL. In either case you need to edit your httpd.conf to configure Apache to work with PHP and then restart the server.
Megjegyzés: Ne feledd, hogy amennyiben elérési ótvonalakat adsz meg az Apache konfigurációs állományaiban Windows alatt, minden hanyattperjelet (\) át kell alakítanod sima perjellé. Tehát a c:\directory\file.ext elérési utat így kell megadnod: c:/directory/file.ext!
You need to insert these three lines to your Apache httpd.conf configuration file to set up the CGI binary:
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
You need to insert these two lines to your Apache httpd.conf configuration file to set up the PHP module for Apache 2.0:
Példa 6-6. PHP and Apache 2.0 as Module
|
Megjegyzés: Remember to substitute your actual path to PHP for the c:/php/ in the above examples. Take care to use either php4apache2.dll or php5apache2.dll in your LoadModule directive and not php4apache.dll or php5apache.dll as the latter ones are designed to run with Apache 1.3.x.
Megjegyzés: If you want to use content negotiation, read related FAQ.
| Figyelem |
Don't mix up your installation with DLL files from different PHP versions. You have the only choice to use the DLL's and extensions that ship with your downloaded PHP version. |
This section contains notes and hints specific to Sun Java System Web Server, Sun ONE Web Server, iPlanet and Netscape server installs of PHP on Windows.
From PHP 4.3.3 on you can use PHP scripts with the NSAPI module to generate custom directory listings and error pages. Additional functions for Apache compatibility are also available. For support in current webservers read the note about subrequests.
To install PHP as a CGI handler, do the following:
Copy php4ts.dll to your systemroot (the directory where you installed Windows)
Make a file association from the command line. Type the following two lines:
assoc .php=PHPScript ftype PHPScript=c:\php\php.exe %1 %* |
In the Netscape Enterprise Administration Server create a dummy shellcgi directory and remove it just after (this step creates 5 important lines in obj.conf and allow the web server to handle shellcgi scripts).
In the Netscape Enterprise Administration Server create a new mime type (Category: type, Content-Type: magnus-internal/shellcgi, File Suffix:php).
Do it for each web server instance you want PHP to run
More details about setting up PHP as a CGI executable can be found here: http://benoit.noss.free.fr/php/install-php.html
To install PHP with NSAPI, do the following:
Copy php4ts.dll to your systemroot (the directory where you installed Windows)
Make a file association from the command line. Type the following two lines:
assoc .php=PHPScript ftype PHPScript=c:\php\php.exe %1 %* |
In the Netscape Enterprise Administration Server create a new mime type (Category: type, Content-Type: magnus-internal/x-httpd-php, File Suffix: php).
Edit magnus.conf (for servers >= 6) or obj.conf (for servers < 6) and add the following: You should place the lines after mime types init.
Init fn="load-modules" funcs="php4_init,php4_execute,php4_auth_trans" shlib="c:/php/sapi/php4nsapi.dll" Init fn="php4_init" LateInit="yes" errorString="Failed to initialise PHP!" [php_ini="c:/path/to/php.ini"] |
Configure the default object in obj.conf (for virtual server classes [Sun Web Server 6.0+] in their vserver.obj.conf): In the <Object name="default"> section, place this line necessarily after all 'ObjectType' and before all 'AddLog' lines:
Service fn="php4_execute" type="magnus-internal/x-httpd-php" [inikey=value inikey=value ...] |
This is only needed if you want to configure a directory that only consists of PHP scripts (same like a cgi-bin directory):
<Object name="x-httpd-php"> ObjectType fn="force-type" type="magnus-internal/x-httpd-php" Service fn=php4_execute [inikey=value inikey=value ...] </Object> |
Restart your web service and apply changes
Do it for each web server instance you want PHP to run
Megjegyzés: More details about setting up PHP as an NSAPI filter can be found here: http://benoit.noss.free.fr/php/install-php4.html
Megjegyzés: The stacksize that PHP uses depends on the configuration of the webserver. If you get crashes with very large PHP scripts, it is recommended to raise it with the Admin Server (in the section "MAGNUS EDITOR").
Important when writing PHP scripts is the fact that Sun JSWS/Sun ONE WS/iPlanet/Netscape is a multithreaded web server. Because of that all requests are running in the same process space (the space of the webserver itself) and this space has only one environment. If you want to get CGI variables like PATH_INFO, HTTP_HOST etc. it is not the correct way to try this in the old PHP 3.x way with getenv() or a similar way (register globals to environment, $_ENV). You would only get the environment of the running webserver without any valid CGI variables!
Megjegyzés: Why are there (invalid) CGI variables in the environment?
Answer: This is because you started the webserver process from the admin server which runs the startup script of the webserver, you wanted to start, as a CGI script (a CGI script inside of the admin server!). This is why the environment of the started webserver has some CGI environment variables in it. You can test this by starting the webserver not from the administration server. Use the command line as root user and start it manually - you will see there are no CGI-like environment variables.
Simply change your scripts to get CGI variables in the correct way for PHP 4.x by using the superglobal $_SERVER. If you have older scripts which use $HTTP_HOST, etc., you should turn on register_globals in php.ini and change the variable order too (important: remove "E" from it, because you do not need the environment here):
variables_order = "GPCS" register_globals = On |
You can use PHP to generate the error pages for "404 Not Found" or similar. Add the following line to the object in obj.conf for every error page you want to overwrite:
Error fn="php4_execute" code=XXX script="/path/to/script.php" [inikey=value inikey=value...] |
Another possibility is to generate self-made directory listings. Just create a PHP script which displays a directory listing and replace the corresponding default Service line for type="magnus-internal/directory" in obj.conf with the following:
Service fn="php4_execute" type="magnus-internal/directory" script="/path/to/script.php" [inikey=value inikey=value...] |
The NSAPI module now supports the nsapi_virtual() function (alias: virtual()) to make subrequests on the webserver and insert the result in the webpage. The problem is, that this function uses some undocumented features from the NSAPI library.
Under Unix this is not a problem, because the module automatically looks for the needed functions and uses them if available. If not, nsapi_virtual() is disabled.
Under Windows limitations in the DLL handling need the use of a automatic detection of the most recent ns-httpdXX.dll file. This is tested for servers till version 6.1. If a newer version of the Sun server is used, the detection fails and nsapi_virtual() is disabled.
If this is the case, try the following: Add the following parameter to php4_init in magnus.conf/obj.conf:
Init fn=php4_init ... server_lib="ns-httpdXX.dll" |
You can check the status by using the phpinfo() function.
Megjegyzés: But be warned: Support for nsapi_virtual() is EXPERIMENTAL!!!
This section contains notes and hints specific to OmniHTTPd on Windows.
Megjegyzés: You should read the manual installation steps first!
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
You need to complete the following steps to make PHP work with OmniHTTPd. This is a CGI executable setup. SAPI is supported by OmniHTTPd, but some tests have shown that it is not so stable to use PHP as an ISAPI module.
Important for CGI users: Read the faq on cgi.force_redirect for important details. This directive needs to be set to 0.
Install OmniHTTPd server.
Right click on the blue OmniHTTPd icon in the system tray and select Properties
Click on Web Server Global Settings
On the 'External' tab, enter: virtual = .php | actual = c:\php\php.exe (use php-cgi.exe if installing PHP 5), and use the Add button.
On the Mime tab, enter: virtual = wwwserver/stdcgi | actual = .php, and use the Add button.
Click OK
Repeat steps 2 - 6 for each extension you want to associate with PHP.
Megjegyzés: Some OmniHTTPd packages come with built in PHP support. You can choose at setup time to do a custom setup, and uncheck the PHP component. We recommend you to use the latest PHP binaries. Some OmniHTTPd servers come with PHP 4 beta distributions, so you should choose not to set up the built in support, but install your own. If the server is already on your machine, use the Replace button in Step 4 and 5 to set the new, correct information.
This section contains notes and hints specific to the Sambar Server for Windows.
Megjegyzés: You should read the manual installation steps first!
This list describes how to set up the ISAPI module to work with the Sambar server on Windows.
Find the file called mappings.ini (in the config directory) in the Sambar install directory.
Open mappings.ini and add the following line under [ISAPI]:
Now restart the Sambar server for the changes to take effect.
This section contains notes and hints specific to Xitami on Windows.
Megjegyzés: You should read the manual installation steps first!
This list describes how to set up the PHP CGI binary to work with Xitami on Windows.
Important for CGI users: Read the faq on cgi.force_redirect for important details. This directive needs to be set to 0. If you want to use $_SERVER['PHP_SELF'] you have to enable the cgi.fix_pathinfo directive.
| Figyelem |
Ha a PHP-t CGI felületen dolgoztatod, ez a szervereden bizonyos támadási felületeket nyit. Kérlek, olvasd el CGI biztonság fejezetünket, hogy megtudd, hogy tudod megvédeni magad ezen támadásokkal szemben. |
Make sure the webserver is running, and point your browser to xitamis admin console (usually http://127.0.0.1/admin), and click on Configuration.
Navigate to the Filters, and put the extension which PHP should parse (i.e. .php) into the field File extensions (.xxx).
In Filter command or script put the path and name of your PHP CGI executable i.e. C:\php\php.exe for PHP 4, or C:\php\php-cgi.exe for PHP 5.
Press the 'Save' icon.
Restart the server to reflect changes.
Mielőtt belevágunk, érdemes megválaszolni azt a kérdést, hogy: "Miért olyan nehéz a fordítás Windows alatt?". Két indokra vezethető vissza:
A Windows (még) nem rendelkezik fejlesztők olyan nagy lélekszámú csapatával, akik szabadon szeretnék megosztani egymás közt forrásaikat. Ennek közvetlen következménye, hogy az ilyen fejlesztésekhez szükséges, elengedhetetlen infrastruktúrális beruházások még nem történtek. Nagyjából a hozzáférhető eszközök mindegyikét Unix alól "hozták át", ezért nem kell meglepődni, ha ez az örökség időnként nagyon szembeötlő.
Az itt következő uasítások legtöbbje "csináld és felejtsd el" jellegű, ezért dőlj hátra, és próbáld meg a lehető leghűségesebben követni azokat.
Ahhoz, hogy a PHP-t lefordítsd, szükséged lesz egy Microsoft fejlesztői környezetre. A Microsoft Visual C++ 6.0-ot ajálnjuk. A letöltött fájlok kicsomagolásához szükséged lesz egy kitömörítő alkalmazásra (pl. Winzip). Ha még nincs unzip programod, letölthetsz egy ingyenes verziót az InfoZip-től.
Mielőtt elkezded, le kell töltened...
..a win32 eszközöket a PHP oldaláról a a http://www.php.net/extra/win32build.zip címről.
..a PHP által használt DNS név-feloldó forrását a http://www.php.net/extra/bindlib_w32.zip címről. Ez a win32build.zip-ban szereplő resolv.lib helyettesítője.
Ha a PHP-t Apache modulként akarod fordítani, szükséged lesz az Apache forrásokra is.
Végül kell maga a PHP 4 forrása. A legutolsó fejlesztői változatra szert tehetsz anonim CVS-t vagy a snapshot-ot használva vagy a legfrissebb forrás tar-t letöltve.
Miután letöltötted a szükséges csomagokat, ki kell tömörítened egy megfelelő helyre.
Készíts egy munkakönyvtárat, ahová a kitömörített fájlokat teheted, pl: C:\work.
Készíts egy win32build könyvtárat a munkakönyvtárad alá (C:\work) és ide csomagold ki a win32build.zip fájlt.
A munkakönyvtáradba (C:\work) hozd létre a bindlib_w32 könyvtárat, majd a bindlib_w32.zip ide tömörítsd ki.
A letöltött PHP forráskódot a munkakönyvtáradba csomagold ki (C:\work).
+--c:\work | | | +--bindlib_w32 | | | | | +--arpa | | | | | +--conf | | | | | +--... | | | +--php-4.x.x | | | | | +--build | | | | | +--... | | | | | +--win32 | | | | | +--... | | | +--win32build | | | | | +--bin | | | | | +--include | | | | | +--lib |
Megjegyzés: A Cygwin-t haszmálók kihagyhatják az legutóbbi lépést. Egy megfelelően telepített Cygwin környezet tartalmazza a szükséges bison.simple és bison.exe fájlokat.
A következő lépésben az fordításhoz szükséges MVC ++ -t állítjuk be. Indítsd el a Microsoft Visual C++ -t, majd a menüből válaszd ki a Tools => Options pontot. A párbeszédablakban válaszd a directories fület. A legördülő listából sorjában válaszd ki az Executables, az Includes és Library files pontokat. Egy jellegzetes listabejegyzések valahogy így mutatnak:
Executable files: c:\work\win32build\bin, Cygwin-t használóknak: cygwin\bin
Include files: c:\work\win32build\include
Library files: c:\work\win32build\lib
Le kell fordítanod a resolv.lib könyvtárat. Döntsd el, hogy debug szimbólumokkal (bindlib - Win32 Debug) vagy anélkül (bindlib - Win32 Release) szeretnél fordítani. Készítsd el a neked megfelelő konfigurációt:
Grafikus felületet használóknak: indítsd el a VC++ programot, válaszd ki a File => Open Workspace menüpontot, keresd meg a c:\work\bindlib_w32 könyvtárat, válaszd ki a bindlib.dsw-t. Ezután válaszd a Build=>Set Active Configuration-t, majd add meg a kívánt konfigurációt. Végül válaszd a Build=>Rebuild All menüpontot.
Parancssort használóknak: bizonyosodj meg arról, hogy a C++ környezeti változók be vannak állítva vagy hogy futtattad a vcvars.bat-ot, majd hajtsd végre a következő parancsokat:
msdev bindlib.dsp /MAKE "bindlib - Win32 Debug"
msdev bindlib.dsp /MAKE "bindlib - Win32 Release"
A kezdésként legjobb egy CGI verziót fordítani.
Grafikus felületet használóknak: indítsd el a VC++ -t, nyisd meg a php4ts munkaterületetet (File => Open Workspace és válaszd ki a c:\work\php-4.x.x\win32\php4ts.dsw-t). Ezután: Build=>Set Active Configuration, és válaszd ki a kívánt konfigurációt, php4ts - Win32 Debug_TS vagy php4ts - Win32 Release_TS, és végül: Build=>Rebuild All.
Parancssort használóknak: győződj meg arról, hogy a szükséges C++ környezeti változók legyenek beállítva vagy a vcvars.bat le lett futtatva, ezután add ki valamelyik alábbi parancsot a c:\work\php-4.x.x\win32 könyvtárból:
msdev php4ts.dsp /MAKE "php4ts - Win32 Debug_TS"
msdev php4ts.dsp /MAKE "php4ts - Win32 Release_TS"
Ennél a pontnál a Debug_TS vagy a Release_TS alkönyvtárban kell lennie egy használható php.exe fájlnak.
Lehetséges a fordító folyamat kissebb testreszabása a main/config.win32.h szerkesztése által. Például megváltoztathatod a php.ini helyét, a beépített kiterjesztéseket, valamint a kiterjesztések alapértelmezett helyét.
Ezután készíthetsz egy CLI verziót, ami a PHP parancssorból történő futtatására van tervezve. A lépések hasonlóak a CGI verzió készítésének lépéseihez, kivéve, hogy a php4ts_cli - Win32 Debug_TS vagy a php4ts_cli - Win32 Release_TS projekt fájlt kell kiválasztanod. Egy sikeres fordítás után egy php.exe-t kell találnod a Release_TS\cli\ vagy a Debug_TS\cli\ könyvtárban.
Megjegyzés: Ha szeretnél használni PEAR-t és a kényelmes parancssori telepítőt, a CLI-SAPI kötelező. További információért a PEAR-ről és a telepítőről olvasd el a PEAR dokumentációt.
Ahhoz, hogy a PHP-nek a Microsoft IIS-hez történő integrálásához szükséges SAPI modult (php4isapi.dll) elkészítsd, a konfigurációdat a php4isapi-whatever-config-ra állítsd be, majd fordítsd le a kívánt dll-t.
A webszerver és a PHP telepítése után valószínűleg néhány kiterjesztést is telepíteni akarsz a szolgáltatáskészlet bővítése érdekében. Azokat a kiterjesztéseket, amelyeket a PHP indulásakor szeretnél indítani, a php.ini-ben kell megadnod. A szkriptjeidben is betöltheted dinamikusan őket a dl() függvény segítségével.
A PHP kiterjesztések DLL-jei a php_ előtaggal vannak ellátva.
A PHP Windows-os verziójába sok kiterjesztés be van építve. Ez annyit jelent, hogy ezen kiterjesztések betöltéséhez nem szükségesek további DLL-ek és az extension direktíva használata. A Windows-os PHP kiterjesztések táblázat olyan kiterjesztéseket tartalmaz, amelyek működéséhez szükségesek, vagy általában szükségesek további PHP DLL állományok. Itt pedig egy lista a beépített kiterjesztésekről:
PHP 4-ben (PHP 4.3.11): BCMath, Caledar, COM, Ctype, FTP, MySQL, ODBC, Overload, PCRE, Session, Tokenizer, WDDX, XML és Zlib
PHP 5-ben (PHP 5.0.4) a következő kiterjesztésekkel bővül a lista: DOM, LibXML, Iconv, SimpleXML, SPL és SQLite. Az alábbiak viszont már nincsenek beépítve: MySQL and Overload.
Az alapértelmezett hely, ahol a PHP keresi a kiterjesztéseket, PHP 4 esetén a c:\php4\extensions, PHP 5 esetén pedig c:\php5. Hogy megváltoztasd ezt a beállítást, hogy megfeleljen a PHP konfigurációdnak, szerkeszd a php.ini fájlt:
Meg kell változtatnod az extension_dir beállítást úgy, hpgy arra a könyvtárra mutasson, ahol a kiterjesztések vannak vagy ahová a php_*.dll fájlokat raktad. Ne feledkezz meg az utolsó visszaperjelről sem. Példa:
Aktiváld az kívánt kiterjesztéseket úgy, hogy a php.ini-ben kitörlöd a megfelelő extension=php_*.dll sor elől a pontosvesszőt (;)
Példa 6-8. A Bzip2 PHP kiterjesztés aktiválása Windows-on
|
Egyes kiterjesztések a működésükhöz további DLL-eket igényelhetnek. Közülük pár megtalálható a disztribúciós csomagban PHP 4 esetén a C:\php\dlls\ könyvtárban, PHP 5 esetén pedig a főkönyvtárban, mások pedig olyan DLL-eket igényelnek, amelyek nincsenek a csomagban, például az Oracle (php_oci8.dll). Ha PHP 4-et telepítesz, másold át a csomagban lévő DLL-eket a C:\php\dlls könyvtárból a főkönyvtárba (C:\php). Ne felejtsd el a C:\php könyvtárat a PATH-ba tenni. (ez a folyamat egy külön FAQ bejegyzésben van leírva).
Ezen DLL közül egyesek nincsenek benne a PHP disztribúcióban. Részletekért lásd a megfelelő kiterjesztés dokumentációját. A PECL-el kapcsolatban olvasd még el a kézikönyv PECL kiterjesztések telepítése című részét. A PECL-ben egyre több PHP kiterjesztés található, ezeket a kiterjesztéseket külön kell letölteni.
Megjegyzés: Ha a PHP-nek a szervermodul verzióját futtatod, ne felejtsd el újraindítani a webszervert, hogy a php.ini-n végzett változások érvénybe lépjenek.
A következő táblázat leír néhány rendelkezésreálló kiterjesztést, és az esetlegesen igényelt DLL-eket.
Táblázat 6-1. PHP kiterjesztések
| Kiterjesztés | Leírás | Megjegyzések |
|---|---|---|
| php_bz2.dll | bzip2 tömörítési függvények | Nincs |
| php_calendar.dll | Naptár függvények | Beépítve a PHP 4.0.3-tól |
| php_cpdf.dll | ClibPDF függvények | Nincs |
| php_crack.dll | Crack függvények | Nincs |
| php_ctype.dll | ctype függvények | Beépítve a PHP 4.3.0-tól |
| php_curl.dll | CURL, kliens URL könyvtári függvények | Szükséges: libeay32.dll, ssleay32.dll (a csomagban) |
| php_cybercash.dll | Cybercash fizetéssel kapcsolatos függvények | PHP <= 4.2.0 |
| php_db.dll | DBM függvények | Ellenjavallt. Használd a DBA függvényeket helyettük (php_dba.dll). |
| php_dba.dll | DBA: DataBase (dbm-stílusú) absztrakciós réteg függvények | Nincs |
| php_dbase.dll | dBase függvények | Nincs |
| php_dbx.dll | dbx függvények | |
| php_domxml.dll | DOM XML függvények | PHP <= 4.2.0 esetén szükséges: libxml2.dll (a csomagban) PHP >= 4.3.0 esetén szükséges: iconv.dll (a csomagban) |
| php_dotnet.dll | .NET függvények | PHP <= 4.1.1 |
| php_exif.dll | EXIF függvények | php_mbstring.dll. A php_exif.dll a php_mbstring.dll után kell betölteni a php.ini-ben. |
| php_fbsql.dll | FrontBase függvények | PHP <= 4.2.0 |
| php_fdf.dll | FDF: Forms Data Format függvények. | Szükséges: fdftk.dll (a csomagban) |
| php_filepro.dll | filePro függvények | Csak olvasási hozzáférés |
| php_ftp.dll | FTP függvények | Beépítve a PHP 4.0.3-tól |
| php_gd.dll | GD könyvtári kép-függvények | A PHP 4.3.2-től eltávolítva. A truecolor függvények nem érhetők el a GD1-ben, helyettük használd a php_gd2.dll-t. |
| php_gd2.dll | GD könyvtári kép-függvények | GD2 |
| php_gettext.dll | Gettext függvények | PHP <= 4.2.0 esetén szükséges: gnu_gettext.dll (a csomagban), PHP >= 4.2.3 esetén szükséges: libintl-1.dll, iconv.dll (a csomagban). |
| php_hyperwave.dll | HyperWave függvények | Nincs |
| php_iconv.dll | ICONV karakterkészlet-konverzió | Szükséges: iconv-1.3.dll (a csomagban), PHP >=4.2.1 iconv.dll |
| php_ifx.dll | Informix függvények | Szükséges: Informix könyvtárak |
| php_iisfunc.dll | IIS menedzsment függvények | Nincs |
| php_imap.dll | IMAP POP3 és NNTP függvények | Nincs |
| php_ingres.dll | Ingres II függvények | Szükséges: Ingres II könyvtárak |
| php_interbase.dll | InterBase függvények | Szükséges: gds32.dll (a csomagban) |
| php_java.dll | Java függvények | PHP <= 4.0.6 esetén szükséges: jvm.dll (a csomagban) |
| php_ldap.dll | LDAP függvények | PHP <= 4.2.0 esetén szükséges: libsasl.dll (a csomagban), PHP >= 4.3.0 esetén szükséges: libeay32.dll, ssleay32.dll (a csomagban) |
| php_mbstring.dll | Multi-Byte String függvények | Nincs |
| php_mcrypt.dll | Mcrypt tömörítő függvények | Szükséges: libmcrypt.dll |
| php_mhash.dll | Mhash függvények | PHP >= 4.3.0 esetén szükséges: libmhash.dll (a csomagban) |
| php_mime_magic.dll | Mimetype függvények | Szükséges: magic.mime (a csomagban) |
| php_ming.dll | Ming függvények Flash-hez | Nincs |
| php_msql.dll | mSQL függvények | Szükséges: msql.dll (a csomagban) |
| php_mssql.dll | MSSQL függvények | Szükséges: ntwdblib.dll (a csomagban) |
| php_mysql.dll | MySQL függvények | PHP >= 5.0.0, szükséges: libmysql.dll (libmysqli.dll, PHP <= 5.0.2) (a csomagban) |
| php_mysqli.dll | MySQLi függvények | PHP >= 5.0.0, szükséges: libmysqli.dll (a csomagban) |
| php_oci8.dll | Oracle 8 függvények | Szükséges: Oracle 8.1+ client libraries |
| php_openssl.dll | OpenSSL függvények | Szükséges: libeay32.dll (a csomagban) |
| php_oracle.dll | Oracle függvények | Szükséges: Oracle 7 kliens könyvtárak |
| php_overload.dll | Objektum túlterhelési függvények | Beépítve a PHP 4.3.0-tól |
| php_pdf.dll | PDF függvények | Nincs |
| php_pgsql.dll | PostgreSQL függvények | Nincs |
| php_printer.dll | Printer függvények | Nincs |
| php_shmop.dll | Osztott memória függvények | Nincs |
| php_snmp.dll | SNMP get and walk függvények | Csak NT esetén! |
| php_soap.dll | SOAP függvények | PHP >= 5.0.0 |
| php_sockets.dll | Socket függvények | Nincs |
| php_sybase_ct.dll | Sybase függvények | Szükséges: Sybase kliens könyvtárak |
| php_tidy.dll | Tidy függvények | PHP >= 5.0.0 |
| php_tokenizer.dll | Tokenizer függvények | Beépítve a PHP 4.3.0-tól |
| php_w32api.dll | W32api függvények | Nincs |
| php_xmlrpc.dll | XML-RPC függvények | PHP >= 4.2.1 esetén szükséges: iconv.dll (a csomagban) |
| php_xslt.dll | XSLT függvények | PHP <= 4.2.0 esetén szükséges: sablot.dll, expat.dll (a csomagban). PHP >= 4.2.1 esetén szükséges: sablot.dll, expat.dll, iconv.dll (a csomagban). |
| php_yaz.dll | YAZ függvények | Szükséges: yaz.dll (a csomagban) |
| php_zip.dll | Zip fájl függvények | Csak olvasási hozzáférés |
| php_zlib.dll | ZLib tömörítő függvények | Beépítve a PHP 4.3.0-tól |
A PHP kiterjesztések számos módon telepíthetőek. A PECL PHP kiterjesztések gyűjteménye, amelyek a PEAR struktúrában találhatóak meg. A következő részek bemutatják ezen kiterjesztések telepítésének módját.
Ezek az utasítások /your/phpsrcdir/-rel jelölik azt a könyvtárat, ahol a PHP forráskód található, extname-el pedig a PECL kiterjesztés nevét. Ezek az utasítások feltételezik a pear parancs ismeretét.
A megosztott kiterjesztések a php.ini-ben az extension direktíva használatával telepíthetők. Lásd még az extensions_dir direktívát és a dl() függvényt. A továbbiakban leírt telepítési módok nem konfigurálják automatikusan a PHP-t, hogy betöltse ezeket a kiterjesztéseket, ezt kézzel kell megtenni.
PHP modulok fordításánál fontos a szükséges eszközök (autoconf, automake, libtool, stb.) megfelelő verziójainak használata. Olvasd el az Anonymous CVS útmutatót, hogy többet megtudj a szükséges eszközökről és verziókról.
Számos módja van a PECL kiterjesztések letöltésének, mint például:
Itt olyan információkat is találsz, mint például a változás napló, kiadási információk, követelmények, javítások, stb. Bár nem minden PECL kiterjesztés rendelkezik honlappal, a legtöbb igen.
pear download extname
A forráskódok letöltésre a pear parancsot is használhatod. Megadhatod azt is melyik verziót akarod letölteni.
CVS
Minden PECL állomány megtalálható a CVS-ben. A http://cvs.php.net/pecl/ címen találod ennek a webes felületét. Ha egyenesen a CVS-ből szeretnél letölteni, hajtsd végre a következő parancsokat (a cvsread felhasználó jelszava phpfi):
$ cvs -d:pserver:cvsread@cvs.php.net:/repository login $ cvs -d:pserver:cvsread@cvs.php.net:/repository co pecl/extname |
Letöltés Windows-al
A Windows felhasználók letölthetik a lefordított PECL binárisokat a PHP letöltés oldalon a Collection of PECL modules címszó alatt vagy egy PECL Snapshot-ot (pillanatfelvételt). Ha szeretnéd a PHP-t Windows alatt fordítani, olvasd el a Win32 Build README-t.
Mint bármilyen más PHP kiterjesztés DLL-t, a telepítéshez tedd a PECL kiterjesztés DLL-eket az extension_dir könyvtárba és hivatkozz rá a php.ini-ben. Például:
extension=php_extname.dll |
Ezután indítsd újra a webszervert.
A PEAR-rel könnyen készíthetsz megosztott PHP kiterjesztéseket a pear parancs használatával. Hajtsd végre a következőt:
$ pear install extname |
Ez letölti az extname kiterjesztés forrását, majd lefordítja. Ennek eredménye egy extname.so állomány, amelyet aztán beírhatsz a php.ini-be.
Amennyiben a rendszer preferred_state (előnyben részesített állapot) változója magasabbra van állítva, mint amilyen az extname-ből rendelkezésre áll, például ha stabilra van állítva de a kiterjesztés még csak béta állapotban van, vagy módosítsd a preferred_state-et a pear config-set paranccsal, vagy pedig add meg a PECL kiterjesztés egy bizonyos verziószámát, valahogy így:
$ pear install extname-0.1.1 |
A pear minden esetben a extension-dir-be fogja másolni az extname.so-t. A php.ini-t ennek megfelelően állítsd be.
Ha a pear használata nem lehetséges, mint például megosztott PECL kiterjesztések CVS-ből történő fordítása, egy megosztott kiterjesztés létrehozása kézzel is elvégezhető a phpize paranccsal. A pear parancs alapvetően megteszi ezt, de kézzel is elvégezhető. Feltéve, hogy a forrásfájl neve extname.tgz, amely az aktuális könyvtárba lett letöltve, tekintsd a következőt:
$ pear download extname $ gzip -d < extname.tgz | tar -xvf - $ cd extname $ phpize $ ./configure && make |
Ha minden rendben zajlik, akkor ez létrehoz egy extname.so állományt, és az extname/-en belül található modules/ és/vagy .libs/ könyvtárba teszi. Helyezd ezt a megosztott kiterjesztést (extname.so) a PHP kiterjesztés könyvtárába, és állítsd be a php.ini-t megfelelően.
Ha szeretnéd a kiterjesztést a PHP-be statikusan belefordítani, tedd a kiterjesztés forrását a PHP forrásában található ext/ könyvtárba. Például:
$ cd /your/phpsrcdir/ext $ pear download extname $ gzip -d < extname.tgz | tar -xvf - $ mv extname-x.x.x extname $ rm package.xml |
Ez az alábbi könyvtárat eredményezi:
/your/phpsrcdir/ext/extname |
Most fordítsd a PHP a szokásos módon:
$ cd /your/phpsrcdir $ ./buildconf --force $ ./configure --help $ ./configure --with-extname --enable-someotherext --with-foobar $ make $ make install |
Megjegyzés: Ahhoz, hogy a 'buildconf'-ot futtasd, szükséged lesz autoconf 2.13 és automake 1.4+ eszközökre (az autoconf későbbi verzióval is működhet, de nem támogatott).
Az, hogy az --enable-extname vagy a --with-extname alakot kell használni, függ a kiterjesztéstől. Tipikusan olyan kiterjesztések esetén, amelyek nem igényelnek külső könyvtárakat, az --enable-t kell használni. Hogy megbizonyosodhass róla, a buldconf után futtasd ezt:
$ ./configure --help | grep extname |
Néhány probléma bizony gyakran előfordul. A leggyakrabban előforduló gondok és válaszok a PHP FAQ-ban olvashatóak, amely része e kézikönyvnek.
Ha még mindig elakadsz, talán valaki a PHP telepítési levelezési listán tud segíteni. Jól teszed, ha először megnézed az archívumot, hátha már valaki megválaszolt egy hasonló kérdést. Az archívum elérhető a support oldalon a http://www.php.net/support.php címen. Az angol PHP telepítési levelezőlistára való feliratkozáshoz küldj egy üres levelet a php-install-subscribe@lists.php.net címre. A levelezőlista címe: php-install@lists.php.net. A magyar PHP levelezőlistára való feliratkozáshoz küldj egy subscribe témamegjelöléssel rendelkező levelet a wl-phplista-request@weblabor.hu. címre. A levelezőlista címe: wl-phplista@weblabor.hu.
Ha segítséget szeretnél kapni valamelyik levelezőlistán, légy szíves próbálj meg precíz lenni, és minden fontos részletet adj meg a környezetről (operációs rendszer, PHP verziószám, web szerver, miként használod a PHP-t - CGI-ként vagy modulként, stb.). Ezenkívül adj meg elég PHP kódot, hogy a többiek reprodukálni és tesztelni tudják a problémát.
Ha úgy gondolod, hogy programhibát találtál a PHP-ben, légy szíves jelentsd a fejlesztőknek (angolul). Lehet, hogy a PHP fejlesztői semmit sem sejtenek felőle, és ha te nem jelented be, előfordulhat, hogy nem lesz kijavítva. Hibákat a bug-követő rendszeren regisztrálhatsz, melynek címe: http://bugs.php.net/. Kérünk, hogy ne küldj hibajelentéseket levelezőlistákra vagy személyes levélként. A hibajelentő rendszer alkalmas új szolgáltatás kérésére is.
Mielőtt bármilyen hibajelentést beküldenél, olvasd el a Hogyan jelentsünk egy hibát című dokumentumot!
A konfigárós fájl (PHP 3-ban php3.ini, PHP 4-től pedig egyszerűen php.ini) beolvasása a PHP indulásakor történik meg. A szervermodul verziókban ez csak egyszer történik meg, ammikor a szerver elindul. A CGI és CLI változatok esetén minden hívás esetén megtörténik
A php.ini-t sorrendben a következő helyeken keresi:
SAPI modul specifikus helyen (Apache 2 esetén a PHPIniDir direktíva, CGI és CLI esetén -c parancssori opció, NSAPI esetén php_ini paraméter, THTTPD esetén PHP_INI_PATH környezeti változó határozza meg)
HKEY_LOCAL_MACHINE\SOFTWARE\PHP\IniFilePath (Windows Registry)
A PHPRC környezeti változó
Aktuális könyvtár (CLI esetén)
A webszerver könyvtára (SAPI modulok esetén), vagy a PHP könyvtára (egyéb esetben Windows-on)
Windows könyvtár (C:\windows vagy C:\winnt) (Windows esetén), vagy a --with-config-file-path fordítási opció
Ha a php-SAPI.ini fájl létezik, (ahol SAPI a használt SAPI, vagyis a fájlnév például php-cli.ini vagy php-apache.ini), ezt fogja a php.ini helyett használni. A SAPI neve a php_sapi_name() függvénnyel kérhető le.
Megjegyzés: Az Apache webszerver induláskor a gyökérkönyvtárra vált, ezért a PHP a gyökérkönyvtárból olvassa be a php.ini-t, ha létezik.
A kiterjesztések által használt php.ini direktívák a megfelelő kiterjesztés oldalain vannak dokumentálva. Az alapvető direktívák listája a függelékben található. Valószínűleg nincs minden PHP direktíva dokumentálva ebben a kézikönyvben. A PHP verziódban alkalmazható direktívák teljes listáját megtalálod az elég jól dokumentált php.ini fájlban, vagy a legfrissebb php.ini-t a CVS-ben találod meg.
Példa 9-1. php.ini példa
|
Ha a PHP-t Apache modulként futtatod, a konfigurációs beállításokat az Apache konfugirációs fájljaiban (httpd.conf) és a .htaccess fájlokban elhelyezett direktívákkal is elvégezheted. Ehhez szükséged lesz "AllowOverride Options" vagy "AllowOverride All" jogosultságra.
A PHP 4 és PHP 5 esetében számos Apache direktíva létezik, amely lehetővé teszi, hogy megváltoztasd a PHP konfigurációt az Apache konfigurációs fájljaiból. Ahhoz hogy megtudd, mely direktívák tartoznak a PHP_INI_ALL, PHP_INI_PERDIR, vagy PHP_INI_SYSTEM kategóriákba, nézd meg a php.ini directivákat felsoroló függeléket
Megjegyzés: A PHP 3 esetén, vannak olyan Apache direktívák, amelyek megfelelnek a php3.ini-ben szereplő direktívák neveinek, annyiban különböznek, hogy a nevek a "php3_" előtaggal vannak ellátva.
Beállítja a megadott direktíva értékét. Hasznlálható PHP_INI_ALL és PHP_INI_PERDIR típusú direktívák esetén. Ha egy előzőleg beállított értéket szeretnél törölni, használd értékként a none-t.
Megjegyzés: Ne használd a php_value-t logikai értékek beállítására, helyette a php_flag-et használhatod (lásd alább).
Logikai konfigurációs direktíva beállítására szolgál. Csak PHP_INI_ALL és PHP_INI_PERDIR típusú direktívák esetén alkalmazható.
Beállítja az adott direkítíva értékét. Ez nem használható .htaccess fájlokban. A php_admin_value-val beállított direktívák nem bírálhatóak felül .htaccess vagy virtualhost direktívákkal. Egy előzőleg beállított érték törlésére használd értékként a none-t.
Logikai konfigurációs direktíva beállítására szolgál. Ez nem használható .htaccess fájlokban. A php_admin_flag beállított direktívák nem bírálhatóak felül .htaccess vagy virtualhost direktívákkal.
Példa 9-2. Példa Apache konfigurációra
|
| Figyelem |
A PHP konstanson nem léteznek PHP-n kívül. A httpd.conf-ban például nem használhatsz PHP konstansokat, mint például az E_ALL vagy E_NOTICE, az error_reporting direktíva beállításához, mivel azoknak nem lesz értelme, ezért 0-nak értékelődnek ki. Ehellyett használd a megfelelő bitmaszk értékeket. Ezek a konstansok php.ini-ben használhatóak. |
Ha a PHP-t Windows-on futtatod, a konfigurációs értékek megváltoztathatóak könyvtáranként a Windows registry használatával. A konfigurációs értékek a HKLM\SOFTWARE\PHP\Per Directory Values registry kulcsban vannak tárolva a könyvtáraknak megfelelő alkulcsokban. A c:\inetpub\wwwroot könyvtár konfigurációs értékei a HKLM\SOFTWARE\PHP\Per Directory Values\c\inetpub\wwwroot kulcsban lesznek tárolva. A könyvtár beállításai érvényesek lesznek minden olyan szkriptre ami az adott könyvtárban, vagy annak bármely alkönyvtárában található. Egy kulcs alatt szereplő érték neve egy PHP konfigurációs direktíva nev kell legyen, az érték pedig a string. Az értékekben szereplő PHP konstansok nem lesznek értelmezve. Csak PHP_INI_USER konfigurációs értékek állíthatók be ily módon, PHP_INI_PERDIR értékek nem.
Attól függetlenül, hogyan futtatod a PHP, bizonyos értékeket a szkripted futásidejében is megváltoztathatsz az ini_set() függvénnyel. További információért lásd az ini_set() függvény dokumentációját.
Ha szeretnéd megtudni a rendszer teljes konfigurációs beállításainak listáját érékekkel együtt, hívd meg a phpinfo() függvényt és vizsgáld a kapott oldalt. Az sajátos konfigurációs direktívák értékét futásidőben a ini_get() vagy a get_cfg_var() függvény segítségével állapíthatod meg.
Amikor a PHP feldolgoz egy fájlt, akkor a nyitó és a záró tag-eket keresi, amelyek megmondják a PHP-nek, hogy kezdje el ill. fejezze be a közöttük lévő kódot értelmezni. Ez a kódértelmező mód teszi lehetővé azt, hogy a PHP kódokat mindenféle dokumentumba be tudjuk ágyazni, mivel mindent, ami a nyitó és záró tag-eken kívül esik, a PHP értelmező figyelmen kívül hagy. PHP kódot legtöbbször HTML dokumentumokba ágyazva fogsz látni, mint ebben a példában is.
<p>Ezt figyelmen kívül hagyja.</p> <?php echo 'Ezt viszont értelmezi.'; ?> <p>Ezt szintén figyelmen kívül hagyja.</p> |
Bonyolultabb struktúrákat is alkalmazhatsz:
Négy különböző nyitó és záró tag pár létezik. Kettő közülük, a <?php ?> és a <script language="php"> </script>, mindig rendelkezésre állnak. A másik kettő a rövid tag-ek és az ASP-szerű tag-ek, ezek ki és be kapcsolhatók a php.ini konfigurációs fájlban. Míg egyesek a rövid tag-eket és az ASP tag-eket kényelmesnek tartják, ezek kevésbé hordozhatóvá teszik a programokat, ezért használatuk nem ajánlott.
Megjegyzés: Ha XML-be, vagy XHTML-be ágyazol PHP kódot, akkor a <?php ?> tag-eket kell használnod, hogy ne térj el a szabványtól.
Példa 10-2. PHP nyitó és záró tag-ek
|
Míg az első és a második példában tárgyalt tag-ek mindig rendelkezésre állnak, az elsőt alkalmazzák széleskörben, és az is az ajánlott.
A rövid tag-ek (harmadik példa) csak akkor használhatók, ha engedélyezve vannak a short_open_tag php.ini konfigurációs fájl direktívával, vagy ha a PHP az --enable-short-tags kapcsólóval volt fordítva.
Megjegyzés: Ha PHP 3-at használsz, akkor a rövid tag-eket a short_tags() függvénnyel is engedélyezheted. Ez csak PHP 3-ban lehetséges!
Az ASP-szerű tag-ek (negyedik példa) csak akkor használhatók, ha engedélyezve vannak az asp_tags php.ini konfigurációs fájl direktívával.
Megjegyzés: Az ASP tag-ek lehetősége a PHP 3.0.4-től létezik.
Megjegyzés: A rövid nyitójelölések használatát kerülni kell újrafelhasználandó, széles körű terjesztésre szánt könyvtárak vagy programok fejlesztésekor, illetve olyan alkalmazások megírásakor, amelyek üzemeltetése felett a program írójának nincs ellenőrzése, Ennek oka, hogy a rövid nyitójelölések nem minden konfigurációban használhatók, így csökkenti a hordozhatóságot. Hordozható, újrafelhasználható komponensek esetén ne használd a rövid nyitójelöléseket!
Hasonlóan a C-hez vagy a Perl-hez, a PHP megköveteli, hogy minden utasítás pontosvesszővel végződön. A PHP záró tag automatikusan magába foglal egy pontosvesszőt is, ezért nem szükséges a PHP rész utolsó utasítását pontosvesszővel zárnod. A záró tag magába foglal egy azonnali soremelést is.
A PHP támogatja a 'C', 'C++' és Unix shell-szerű (Perl stílusú) megjegyzéseket. Például:
<?php
echo 'Ez egy teszt'; // egysoros c++ szerű megjegyzés
/* többsoros komment
még egy sor megjegyzés */
echo 'ez egy másik teszt';
echo 'egy végső teszt'; # egy shell-szerű komment
?> |
Az egysoros megjegyzések csak a sor végéig vagy az aktuális PHP kódblokk végéig tart attól függően, melyik van előbb. Ez azt jelenti, hogy a // ?> sorban az ez után álló HTML kód kiírásra kerülk, a ?> zárójelölés visszaállítja a HTML módot, és ezt a // nem tudja befolyásolni. Amennyiben az asp_tags php.ini beállítás engedélyezve van, a fentiek az asp féle kódblokkzáró címkékre is vonatkozik.
A 'C'-szerű kommentek az első */ karakterpárig tartanak. Vigyázz, nehogy egymásbaágyazd a 'C'-szerű megjegyzéseket, amely könnyen megtörténhet, ha nagy kódrészleteket kommentezel ki.
A PHP nyolc primitív típust támogat.
A négy skalár típus:
A két összetett típus: Végül két speciális típus: Ez a kézikönyv bevezet még néhány pszeudo-típust csak az olvashatóság kedvéért: Találhatsz még referenciákat a "double"-ra. Tekintsd a double-t ugyanolyannak, mint a float. A két különböző név csupán történelmi okokból létezik.A változó típusát rendszerint nem a programozó adja meg [persze van beleszólása...], hanem a PHP futási időben határozza meg a változó környezetétől függően.
Megjegyzés: Ha egy kifejezés értékére és/vagy típusára vagy kiváncsi, akkor használd a var_dump() függvényt.
Megjegyzés: Ha csak a típusára van szükség könnyen olvasható formában, akkor a gettype()-ot kell alkalmazni. Típusellenőrzésre viszont ne ezt, hanem az is_type függvényeket kell használni a programokban. Néhány példa:
<?php $bool = TRUE; // boolean $str = "ize"; // string $int = 12; // integer echo gettype($bool); // kiírja, hogy "boolean" echo gettype($str); // kiírja, hogy "string" // Ha ez integer, megnöveljük néggyel if (is_int($int)) { $int += 4; } // Ha a $bool változó string típusú, kiírjuk // (ez nem fog kiírni semmit) if (is_string($bool)) { echo "String: $bool"; } ?>
Ha egy változó típusát egy adott típusra kell konvertálnunk, castolhatjuk a változót, vagy alkalmazzuk rá a settype() függvényt.
A változó különbözőképp értékelődhet ki bizonyos helyzetekben, attól függően, hogy az adott pillanatban milyen típusú. Bővebb leírásért lásd még a Bűvészkedés a típusokkal című részt! Érdekesek lehetnek még számodra a típus összehasonlító táblázatok, ezek példát adnak különféle típus összehasonlításra.
Ez a legegyszerűbb típus. Egy boolean igazságértéket fejez ki. Lehet vagy TRUE (igaz), vagy FALSE (hamis).
Megjegyzés: A logikai adattípus a PHP 4-esben került bevezetésre.
Egy logikai érték megadásához használhatod a TRUE vagy FALSE szavakat, szükség szerint. Egyik jelentése sem függ a kis- és nagybetűs írásmódtól.
Tipikus valamilyen operátor használatakor kapsz boolean típusú értéket, amit egy vezérlési szerkezetben fel tudsz használni.
<?php
// A == operátor egyenlőséget vizsgál
// majd boolean-t ad vissza
if ($akcio == "verzio_kiirasa") { // a == operátor boolean értékkel tér vissza
echo "Ez az 1.23-as változat";
}
// ez nem szükséges...
if ($elvalaszto_kiirasa == TRUE) {
echo "<hr>\n";
}
// ...mivel egyszerűen ez is működik
if ($elvalaszto_kiirasa) {
echo "<hr>\n";
}
?> |
Ha kifejezetten boolean típusúvá szeretnél alakítani egy értéket, használd a (bool) vagy a (boolean) típusátalakítást. A legtöbb esetben azonban nem kell ezt alkalmaznod, mivel az érték automatikusan átalakul, ha egy operátor, függvény, vagy vezérlési szerkezet boolean típusú argumentumot vár.
Lásd még a Bűvészkedés a típusokkal című részt.
Amikor boolean típusúvá kell alakítani egy értéket, az alábbiak FALSE értéket adnak:
a boolean típusú FALSE
az integer (egész)típusú 0 (nulla)
a float (lebegőpontos) 0.0 (nulla)
egy elemeket nem tartalmazó array (tömb)
egy attribútumokat nem tartalmazó object (objektum) (csak PHP 4)
a speciális NULL érték (beleétve a nem beállított - hivatkozást megelőzően nem definiált - változókat)
| Figyelem |
A -1 is TRUE lesz, mint minden más nem nulla (akár negatív, akár pozitív) szám! |
<?php var_dump((bool) ""); // bool(false) var_dump((bool) 1); // bool(true) var_dump((bool) -2); // bool(true) var_dump((bool) "ize"); // bool(true) var_dump((bool) 2.3e5); // bool(true) var_dump((bool) array(12)); // bool(true) var_dump((bool) array()); // bool(false) var_dump((bool) "false"); // bool(true) ?> |
Egy integer a következő halmaz része: Z = {..., -2, -1, 0, 1, 2, ...}.
Lásd még a Tetszőleges pontosságú egészek, Lebegőpontos számok és BCMath tetszőleges pontosságú matematikai függvények című részeket.
Az egészek megadhatók decimális (10 alapú), hexadecimális (16 alapú) vagy oktális (8 alapú) számként, opcionális előjellel (- vagy +).
Ha az oktális formát választod, a számot egy 0 (nulla) jeggyel kell kezdened, ha a hexadecimálisat, akkor 0x-el.
Az integer típus értelmezési tartományán kívül eső egész értékek float típussá alakulnak. Ha valamely művelet eredménye kívül esik a integer értelmezési tartományán, akkor az eredmény automatikusan float típusúvá konvertálódik.
<?php $nagy_szam = 2147483647; var_dump($nagy_szam); // kimenete: int(2147483647) $nagyobb_szam = 2147483648; var_dump($nagyobb_szam); // kimenete: float(2147483648) // ez nem működik hexadecimálisan megadott egészekre: var_dump( 0x100000000 ); // kimenete: int(2147483647) $millio = 1000000; $nagy_szam = 50000 * $millio; var_dump($nagy_szam); // kimenete: float(50000000000) ?> |
| Figyelem |
Sajnálatosan meg kell említenünk, hogy a PHP 4.0.6-ban ez az átalakítás nem működött mindig pontosan negatív számok használatakor, például: ha a -50000 * $millio műveletet eredménye: -429496728. Ha mindkét operandus pozitív, nincs semmi probléma. Ezt a hiba ki lett javítva a PHP 4.1.0-ben. |
PHP-ben nincs egész osztás. Az 1/2 művelet a 0.5 float (lebegőpontos) értéket eredményezi. Alkalmazhatsz típuskonverziót integer-re lefele kerekítéshez, vagy használhatod a round() függvényt.
Ha kifejezetten integer típusúvá szeretnél alakítani egy értéket, használd az (int) vagy az (integer) típusátalakítást. A legtöbb esetben azonban nem kell ezt alkalmaznod, mivel az érték automatikusan átalakul, ha egy operátor, függvény, vagy vezérlési szerkezet integer típusú argumentumot vár. Az intval() függvénnyel is alakíthatsz integer-ré.
Lásd még a Bűvészkedés a típusokkal című részt.
A FALSE (hamis) érték a 0 (nulla) egész számmá alakul, a TRUE (igaz) érték az 1 (egy) egész számot adja.
Lebegépontos számok egész értékké alakításakor a szám tört része elvész, azaz lefelé kerekítés történik.
Ha a lebegőpontos szám az egész tartományon kívül esik (általában +/- 2.15e+9 = 2^31), az eredmény nem definiált, mivel a lebegőpontos szám nem rendelkezik elég precizitással, hogy pontos egész eredményt kapj. Sem warning, sem notice szintű hiba nem lép fel ebben az esetben!
| Figyelem |
Soha ne alakíts egy ismeretlen törtszámot integer típusúvá, mivel ez időnként nem várt eredményekhez vezethet. Lásd a a lebegőpontos számok pontotsságának problémái című részt. |
| Figyelem |
Az egésszé alakítás viselkedése más típusokra nem definiált. Jelenleg ezek az átalakítások megegyeznek azzal, mintha először logikai, majd utána egész értékké alakítottad volna a kiindulási értéket. Erre a viselkedeésre azonban nem szabad építeni, mivel minden figyelmeztetés nélkül megváltozhat. |
A lebegőpontos számok ("float", "valós szám") az alábbi szintaxisok bármelyikével hozhatóak létre:
Formálisan:LNUM [0-9]+
DNUM ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM ( ({LNUM} | {DNUM}) [eE][+-]? {LNUM}) |
| Lebegőpontos számok pontossága |
Elég gyakran előfordul, hogy egyszerű decimális törtek, mint a 0.1 és a 0.7 nem konvertálhatóak pontosan bináris megfelelőikre kis veszteség nélkül. Ez zavaró eredményekhez vezethet, például floor((0.1+0.7)*10) tipikusan 7 értékkel tér vissza, az elvárt 8 helyett, a belső ábrázolás miatt, ami valójában 7.9999999999.... Ez azzal a ténnyel van kapcsolatban, hogy lehetetlen megjeleníteni néhány törtet véges számú decimálisan számjeggyel. Például 1/3 decimálisan 0.3333333. . . értékké válik. Ezért soha ne bízz meg a törtszámok eredményeiben az utolsó jegyig, és soha se hasoníts össze két lebegőpontos számot pontos egyenlőségre. Ha nagyobb pontosságú számokra van szükséges, használd a tetszőleges pontosságú matematikai függvényeket vagy a gmp függvényeket. |
A stringek float-ra történő konvertálásáról a Stringek átalakítása számmá című részben találsz információt. Más típusú értékek esetén a konverzió pontosan úgy történik, mintha előbb integer-ré konvertálódna, majd az eredmény float-ra. További információért lásd még a Egész értékké alakítás című részt. A PHP 5-ös verziójától ha objektumot float-tá alakítasz, figyelmeztetés (notice) szintű hibajelzés keletkezik.
A string karakterek sorozata. PHP-ben egy karakter pontosan egy bytenak felel meg, így 256 különböző karakter lehetséges. Ez azt is jelenti, hogy a PHP-nek jelenleg nincs beépített Unicode támogatása. Néhány Unicode támogatásért lásd a utf8_encode() és a utf8_decode() függvényeket.
Megjegyzés: Nem okozhat problémát a stringek körében, hogy túl hosszúvá válnak. Semmiféle korlát nem létezik a PHP által kezelt stringek méretére, ezért nem kell tartani a hosszú stringektől.
A stringeket háromféleképpen lehet létrehozni.
A legkönnyebben úgy adhatunk meg egy egyszerű stringet, hogy aposztrófok (' karakterek) közé tesszük.
Ha a stringben egy aposztófot szeretnél elhelyezni, és azzal nem a string végét szeretnéd jelezni, más nyelvekhez hasonlóan egy visszaperjel karaktert kell alkalmaznod az aposztóf előtt (\). Ha egy aposztróf, vagy a string vége előtt el szeretnél helyezni egy visszaperjelet, meg kell dupláznod azt. Figyelj arra, hogy ha bármilyen más karakter elé teszel visszaperjelet, a visszaperjel meg fog jelenni a stringben. Emiatt gyakran nincs szükség magának a visszaperjelnek a duplázására.
Megjegyzés: PHP 3 használatakor azonban egy E_NOTICE szintű figyelmeztetést kapsz, ha ezt kihasználod.
Megjegyzés: A többi móddal ellentétben, az aposztrófos stingben a változók értékei és az escape szekvenciák nem helyettesítődnek be.
<?php echo 'Ez itt egy egyszerű string'; echo 'A stringekbe újsor karaktereket is építhetsz, ilyen formában. Ez így szépen működik.'; // Kimenet: Arnold egyszer azt mondta: "I'll be back" echo 'Arnold egyszer azt mondta: "I\'ll be back"'; // Kimenet: You deleted C:\*.*? echo 'You deleted C:\\*.*?'; // Kimenet: You deleted C:\*.*? echo 'You deleted C:\*.*?'; // Kimenet: Nem helyettesítődik be \n az újsor karakter echo 'Nem helyettesítődik be \n az újsor karakter'; // Kimenet: A $vóltozók $szintén nem helyettesítődnek be echo 'A $vóltozók $szintén nem helyettesítődnek be '; ?> |
Ha egy stringet idézőjelek (") közé helyezünk, a PHP több speciális jelölés feldolgozására lesz képes:
Táblázat 11-1. Speciális jelölések idézőjeles stringben
| jelölés | jelentése |
|---|---|
| \n | újsor (LF vagy 0x0A (10) ASCII kódú karakter) |
| \r | kocsivissza (CR vagy 0x0D (13) ASCII kódú karakter) |
| \t | vízszintes tabulátor (HT vagy 0x09 (9) ASCII kódú karakter) |
| \\ | visszaperjel |
| \$ | dollárjel |
| \" | idézőjel |
| \[0-7]{1,3} | egy karaktersorozat, ami oktális számokra illeszkedik |
| \x[0-9A-Fa-f]{1,2} | egy karaktersorozat, ami hexadecimális számokra illeszkedik |
Ha bármilyen más karakter elé visszaperjelet írsz, ebben az esetben is ki fog íródni a visszaperjel.
A legfontosabb jellemzője az idézőjeles stringeknek az, hogy a változók behelyettesítésre kerülnek. Lásd a változók behelyettesítése című részt további részletekért.
Egy másfajta módszer a stringek megadására a heredoc szintaxis ("<<<"). [ez itt megint nem elírás, kedves unix-shell programozó!] A <<< jelzés után egy azonosítót kell megadni, majd a stringet, és végül az azonosítót mégegyszer, ezzel zárva le a stringet.
A lezáró azonosítónak mindenképpen a sor legelső karakterén kell kezdődnie. Ugyancsak figyelni kell arra, hogy ez az azonosító is az általános PHP elemek elnevezési korlátai alá tartozik: csak alfanumerikus karaktereket és aláhúzást tartalmazhat, és nem kezdődhet számjegy karakterrel.
| Figyelem | |
Nagyon fontos, hogy odafigyelj arra, hogy a lezáró azonosítót tartalmazó sor ne tartalmazzon semmi mást, csupán esetleg egy pontosvessző (;) karaktert. Ez még pontosabban azt is jelenti, hogy az azonosító nem lehet beljebb kezdve, és nem szabad semmilyen szóköz vagy tabulátor karaktert sem elhelyezni a pontosvessző előtt vagy után. Fontos, hogy az záróazonosító előtt szerepelnie kell egy újsor karakternek az operációs rendszernek megfelelően. Ez például Macintosh-on \r. Ha ezt a szabály megsérted és a záróazonosító nem "tiszta", akkor nem lesz záróazonosítónak tekitve, így a PHP tovább fogja keresni. Ebben az esetben, ha nem talál érvényes záróazonosítót, akkor szintaktikai hibát fog adni, ahol a hiba sorának száma a szkript végére fog mutatni. Nem megengedett a heredoc szintaxis használata az osztályok attribútumainak inicializálásakor. Ilyen esetben más string-szintaxist kell használnod. |
A heredoc az idézőjeles stringekhez hasonlóan működik, az idézőjelek nélkül. Ez azt jelenti, hogy nem kell visszaperjellel jelülni az idézőjeleket a szövegben, de a fenti speciális jelölések használhatóak. A változók értékei behelyettesítődnek, de az idézőjeles karaktersorozatokhoz hasonlóan gondosan kell ügyelni a komplex változó hivatkozások megadására.
Példa 11-4. "Heredoc" string példa [VAS: Vége A Stringnek de helyette lehet bármi]
|
Megjegyzés: A heredoc a PHP 4-esben került a nyelvbe.
Ha egy stringet idézőjelek között, vagy heredoc szintaxissal adsz meg, a jelölt változók értékei behelyettesítésre kerülnek.
Kétféleképpen lehet megadni egy változót: az egyszerű és a komplex formátummal. Az egyszerű forma a leggyakoribb és legkényelmesebb. Lehetőséget ad egy skalár, tömb érték vagy egy objektum tulajdonság beillesztésére.
A komplex szintaxis a PHP 4-es változatában került a nyelvbe, és a jelölésben használatos kapcsos zárójelekről ismerhető fel.
Ha dollár ($) jelet talál a PHP egy stringben, mohón megkeresi az összes ezt követő azonosítóban is használható karaktert, hogy egy érvényes változónevet alkosson. Használj kapcsos zárójeleket, ha pontosan meg szeretnéd határozni, meddig tart egy változó.
<?php
$ingatlan = 'ház';
echo "kertes $ingatlan kerítéssel"; // működik, szóköz nem lehet változónévben
echo "páros $ingatlanszám"; // nem működik, az 's' és további karakterek lehetnek változónévben
echo "páros ${ingatlan}szám"; // működik, mert pontosan meg van adva a név
echo "páros {$ingatlan}szám"; // működik, mert pontosan meg van adva a név
?> |
Hasonlóképpen meg lehet adni tömbindexet vagy objektum tulajdonságot is. A tömbindexek esetében a záró szögletes zárójel (]) jelöli az index végét, az objektum tulajdonságoknál az egyszerű skalárok szabályai érvényesek, habár objektum tulajdonágok esetén nem használható a fenti trükk.
<?php
// Ezek a példák a tömbök stringen belüli használatára vonatkoznak.
// Stringen kívül mindig tedd idézőjelbe a tömb string típusú indexeit
// és ne használj {kapcsos zárójeleket} stringen kívül.
// Irassunk ki minden hibát
error_reporting(E_ALL);
$gyumolcsok = array('eper' => 'piros', 'alma' => 'zöld');
// Működik, de lásd az $ize[valami] karakterláncon kívüli problémáját
echo "Az alma $gyumolcsok[alma]."; // ez másképpen használandó karaktersorozatokon kívül.
// Működik
echo "Az alma {$gyumolcsok['alma']}.";
// Működik, de a PHP egy alma nevű konstanst keres először
// mint ahogy alább le van írva
echo "A alma is {$gyumolcsok[alma]}.";
// Nem működik, kapcsos zárójeleket kellene használni. Szintaktikai hibát epirosményez.
echo "A alma is $gyumolcsok['alma'].";
// Működik
echo "A alma is " . $gyumolcsok['alma'] . ".";
// Működik
echo "A négyzet $negyzet->szelesseg méter széles.";
echo "A négyzet $negyzet->szelesseg00 centiméter széles."; // nem működik
// A megoldás érdekében lásd a komplex szintaxis szakaszt!
?> |
Bármely ennél komplexebb helyettesítéshez a komplex szintaxis használatos.
Ezt nem azért nevezzük komplexnek, mert a szintaxis komplex, hanem azért, mert így komplex kifejezések helyettesítésére nyílik lehetőség.
Gyakorltilag bármilyen változó érték behelyettesíthető ezzel a szintaxissal. Egyszerűen úgy kell megadni az értéket adó kifejezést, mintha a stringen kívül dolgoznál vele, és utána { és } jelek közé kell zárni. Mivel a '{' jel megadására nincs speciális jelölés, ez a forma csak akkor fog működni, ha a { után közvetlenül egy $ jel található. (Használhatod a "{\$" vagy "\{$" jelöléseket, ha a stringben a "{$" sorozatot szeretnéd beilleszteni, és nem változóhelyettesítést adsz meg). Néhány példa, ami tisztázhatja a félreértéseket:
<?php
// Irassunk ki minden hibát
error_reporting(E_ALL);
$oriasi = 'fantasztikus';
// Nem működik, kimenet: Ez { fantasztikus}
echo "Ez { $oriasi}";
// Működik, kimenet: Ez fantasztikus
echo "Ez {$oriasi}";
echo "Ez ${oriasi}";
// Működik
echo "Ez a négyzet {$negyzet->szelesseg}00 cm széles.";
// Működik
echo "Ez működik: {$arr[4][3]}";
// Ez hibás ugyanazért, amiért $ize[bigyo] hibás stringen
// kívül. Más szóval, működik, de mivel a PHP az ize nevű
// konstanst keresi előszőr, E_NOTICE szintű hibát
// fog adni (undefined constant).
echo "Ez wrong: {$arr[ize][3]}";
// Működik. Amikor többdimenziós tömböket használsz, stringen
// belül mindig vedd körük kapcsos zárójelekkel
echo "Ez működik: {$arr['ize'][3]}";
// Működik.
echo "Ez működik: " . $arr['ize'][3];
echo "Még így is írhatod: {$obj->values[3]->nev}";
echo "Ez a $nev nevű valtozó értéke: {${$nev}}";
?> |
A string karaktereire nullától számozott indexekkel lehet hivatkozni, a string neve után megadott kapcsos zárójelek között.
Megjegyzés: Kompatibilitási okokból a tömböknél használatos szögletes zárójelek is alkalmazhatóak a karakterek eléréséhez. Ez a tömb jelzés azonban nem javasolt a PHP 4-től.
Stringeket a '.' (pont) stringösszefűző operátorral tudsz összefűzni. A '+' (összeadás) operátor nem alkalmas erre a feladatra. Lásd a String operátorok című részt további információkért.
Számos hasznos függvény létezik stringek manipulálásához.
Lásd a string függvények című részt általános függvényekért, a reguláris kifejezés függvényeket fejlett kereséshez és cserékhez (két formában: Perl és POSIX kiterjesztett).
Külön függvények léteznek URL stringekhez, és stringek kódolásához/dekódolásához (mcrypt és mhash kódolások).
Végül ha ezek között sem találod, amit keresel, lásd a karakter típus függvényeket.
Stringgé konvertálni a (string) módosítóval vagy a strval() függvénnyel tudsz. A string konverzió automatikusan végrehajtódik olyan környezetben, ahol string értékre van szükség. Ez echo() és print() függvények használatánál megtörténik, vagy olyankor, amikor változó értékét stringgel hasonlítod össze. A Típusok és Bűvészkedés a típusokkal részek elolvasása segíthet a következők megértésében. Lásd még a settype() függvényt.
A boolean TRUE érték az "1" stringgé, a FALSE pedig a "" (üres string) stringgé konvertálódik. Ily módon alakítgathatsz oda-vissza a logikai és szöveges adatok között.
Egy egész (integer) vagy egy lebegőpontos szám (float) úgy konvertálódnak, hogy az eredményül kapott string a szám számjegyeiből áll (beleértve az exponenciális részt lebegőpontos számok esetén).
A tömbök mindig az "Array" stringgé konvertálódnak, tehát így nem tudod kiiratni egy tömb tartalmát echo() vagy print() függvénnyel Egy elem kiírásához használj valami ehhez hasonlót: echo $arr['ize']. Lásd lejjebb a teljes tartalom kiírására vonatkozó javaslatokat.
Az objektumok mindig az "Object" stringgé konvertálódnak. Ha egy attribútumának az értékét szeretnéd kiírni, olvasd el a lenti bekezdéseket. Ha azt szeretnéd kideríteni, hogy egy objektum melyik osztálynak a példánya, használd a get_class() függvényt. A PHP 5-ös verziójától a konverzió az objektum __toString() metódusának meghívásával történik.
Az erőforrások (resource) mindig "Resource id #1" formájú strigekké alakítódnak át, ahol 1 az erőforrás egyedi azonosító száma, amelyet a PHP oszt ki futásidőben. Ha az erőforrás típusát szeretnéd megtudni, használd a get_resource_type() függvényt.
A NULL mindig az üres stringgé konvertálódik.
Amint fent olvashattad, tömbök, objektumok és erőforrások kiírása nem szolgáltat semmi hasznos információt magukról az értékekről. A hibakezelés (debug) esetén használható értékek kiírására egy jobb módszer megismeréséhez tanulmányozd a print_r() és a var_dump() függvényeket.
A PHP értékeket alakíthatod úgy is stringgé, hogy örökre el tudd tárolni azokat. Ezt a módszert szerializációnak nevezik, és a serialize() függvény alkalmazható erre. A PHP értékeket XML struktúrába is tudod szerializálni, abban az esetben, ha van a PHP konfigurációdban WDDX.
Amikor egy string számként értékelődik ki, az eredmény típusa a következőképp kerül meghatározásra.
A string lebegőpontosként értékelődik ki, ha a '.', 'e', vagy 'E' karakterek bármelyikét tartalmazza. Egyébként egészként értékelődik ki.
Az érték meghatározása a string első karakterei alapján történik. Ha a string érvényes számmal kezdődik, ez az érték kerül felhasználásra. Máskülönben az érték 0 lesz [nulla, nem nagy O betű]. Érvényes számnak tekintendő, amelynek opcionális előjelét egy vagy több számjegy követi (melyben lehet egy tizedespont), végül lehet exponense. Az exponens egy 'e' vagy 'E' karakter, melyet egy vagy több szám követ.
<?php $ize = 1 + "10.5"; // $ize most float (11.5) $ize = 1 + "-1.3e3"; // $ize most float (-1299) $ize = 1 + "bob-1.3e3"; // $ize most integer (1) $ize = 1 + "bob3"; // $ize most integer (1) $ize = 1 + "10 Kicsi Pingvin"; // $ize most integer (11) $ize = 4 + "10.2 Kicsi Pingvinke" // $ize most integer (14) $ize = "10.0 disznó " + 1; // $ize most integer (11) $ize = "10.0 disznó " + 0.5; // $ize most float (10.5) [szóval 10 disznó, meg egy féldisznó] ?> |
Ha többet szeretnél megtudni erről a konverzióról, akkor nézd meg a Unix manualt strtod(3). [=RTFM]
Ha szeretnéd kipróbálni valamelyik fejezetbeli példát, elmásolhatod innen a példákat és beszúrhatod az alábbi sort, hogy lásd mi is történik.
[Ahhoz nem árt azért előbb érteni a beszúrt sort. A beszúrandó string elején a "\" azért van, hogy a $ize helyére NE a ize változó értéke kerüljön, hanem a \$ hatására a $ karakter íródjon ki, majd a ize karaktersor, egy egyenlőségjel, és utána a $ize változó értéke. Az első "\" hatására ugyanis a köv. karakter ("$") elveszti különleges jelentését, és kimásolódik a kimenetre, majd jön a "ize=" szöveg, ez is úgy, ahogy van a kimenetre kerül, a fordító nem is találkozott változóval, amit be kellene helyettesíteni. Aztán jön a $ize, ezt már felismeri a fordító, és a változó értékét írja ki]:
Ne reméld, hogy egy karaker kódját megkapod, ha egésszé konvertálod (mint ahogyan például C-ben tennéd). Használd a ord() és a chr() függvényeket a karakterkódok és a karakterek közötti konverzióra.
A PHP tömbjei rendezett leképezéseket valósítanak meg. A leképezés értékeket rendel kulcsokhoz. Ez a típus sokféleképpen használható, mint egy hagyományos tömb, egy lista (vektor), hash tábla, szótár, kollekció, halmaz, sor, és mások. Mivel egy újabb PHP tömb szerepelhet értékként, könnyen szimulálhatsz fákat.
Az említett struktúrák leírása ezen kézikönyv kereteibe nem fér bele, de legalább egy példát mutatunk mindegyikre. További információkért külső forrásokat kell igénybe venned erről az igen széles témáról.
Egy array (tömb) típusú változót az array() nyelvi elemmel tudsz létrehozni, amely számos vesszővel elválasztott kulcs => érték párt vár.
array( [kulcs =>] érték
, ...
)
// a kulcs lehet integer vagy string
// az érték bármilyen érték lehet |
A kulcs lehet integer vagy string típusú. Ha a kulcs egy integer szabályos reprezentációja, akkor egészként értelmezi. (azaz a "8"-at 8-ként értelmezi, a "08"-at pedig "08"-nak). Ha a kulcs-nak valós értéket adsz meg, akkor azt egésszé (integer) alakítja. PHP-ben nincs külön indexelt és asszociatív tömb típus, csak egyféle tömb típus van, amely tartalmazhat mind egész mind string indexeket.
Az érték bármilyen típusú lehet.
<?php
$arr = array("tombocske" => array(6 => 5, 13 => 9, "a" => 42));
echo $arr["tombocske"][6]; // 5
echo $arr["tombocske"][13]; // 9
echo $arr["tombocske"]["a"]; // 42
?> |
Ha nem adsz meg kulcsot egy adott értékhez, akkor annak a kulcsa az egész típusú indexek maximuma + 1 lesz. Ha olyan kulcsot adsz meg, amelyhez már létezik hozzárendelt érték, az érték felül lesz írva.
<?php // Ez a tömb ugyanaz mint... array(5 => 43, 32, 56, "b" => 12); // ...ez a tömb array(5 => 43, 6 => 32, 7 => 56, "b" => 12); ?> |
| Figyelem |
Az indexgenerálás fent leírt algoritmusa PHP 4.3.0-tól megváltozott. Ha egy olyan tömbhöz adsz hozzá index nélküli elemet, amelyben a legnagyobb index értéke nagatív, az új elem indexe nulla (0) lesz. Azelőtt az új index a legnagyobb index + 1 lett úgyanúgy mint pozitív indexek esetén. |
Ha TRUE-t adsz meg kulcsként az 1 egész típusú értéket fogja jelenteni, a FALSE pedig a 0-át. Ha kulcsként NULL-t adsz meg, üres stringként lesz értelmezve. Az üres string használata kulcsként létrehoz (vagy felülír) egy üres string kulcsot és az értéket; eltérően az üres szögletes zárójelektől.
Nem használhatsz tömböt vagy objektumot kulcsként. Ha mégis megpróbálod, egy Illegal offset type figyelmeztetést fogsz kapni.
Meglévő tömbök is módosíthatóak konkrét értékek megadásával.
Ezt úgy tudod megtenni, hogy a tömb neve után szögletes zárójelekben megadod a kulcsot, amit módosítani szeretnél. Ha elhagyod a kulcsot, és csak egy üres szögletes zárójel párt ("[]") adsz meg a változó neve után, a tömb végére illeszthetsz elemet.
$tomb[kulcs] = érték; $tomb[] = érték; // a kulcs lehet integer (egész szám) vagy string // az érték bármi lehet |
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // itt ez ugyanaz mint a $arr[13] = 56;
$arr["x"] = 42; // Ez hozzáad egy új elemet
// a tömbhöz "x" kulccsal
unset($arr[5]); // Ez eltávolítja az elemet a tömbből
unset($arr); // Ez az egész tömböt törli
?> |
Megjegyzés: Mint ahogy fentebb említettük, ha a szögletes zárójelek között nem adsz meg kulcsot, akkor a létező indexek maxumuma + 1 lesz az új elem kulcsa. Ha még nincs egész index, akkor ez 0 (nulla) lesz. Ha olyan kulcsot adsz meg, amelyhez már van érték rendelve, az érték felül lesz írva.
Figyelem Az indexgenerálás fent leírt algoritmusa PHP 4.3.0-tól megváltozott. Ha egy olyan tömbhöz adsz hozzá index nélküli elemet, amelyben a legnagyobb index értéke nagatív, az új elem indexe nulla (0) lesz. Azelőtt az új index a legnagyobb index + 1 lett úgyanúgy mint pozitív indexek esetén.
Az automatikus indexeléshez használd legnagyobb szám nem kell abban a pillanatban létezzen a tömbben. Egyszerűen csak kellett valamikor létezett a tömbben a legutóbbi újraindexelés óta. A következő példa szemlélteti ezt:
<?php // Létrehozunk egy egyszerű tömböt $array = array(1, 2, 3, 4, 5); print_r($array); // Most kitörlünk minden elemet, de magát a tömböt nem foreach ($array as $i => $ertek) { unset($array[$i]); } print_r($array); // Hozzáadunk egy elemet (az új kulcs 5 lesz az elvárt 0 helyett) $array[] = 6; print_r($array); // Újraindexeljük: $array = array_values($array); $array[] = 7; print_r($array); ?>A fenti példa a következő kimenetet adja:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )
Létezik néhámy függvény a tömbökkel való munka megkönnyítésére. Lásd a tömb függvények című részt.
Megjegyzés: Az unset() függvénnyel lehet egy értéket a tömbből törölni. Figyelj arra, hogy a tömb nem lesz újraindexelve! Ha csak a "szokásos egész indexet" használod (nullától kezdve egyessével növelve), az újraindexelés hatását a array_values() függvénnyel érheted el.
A foreach vezérlési szerkezet kifejezetten a tömbök számára jött létre. Egy egyszerű módszert ad tömbökön való végiglépkedésre.
Minden string típusú kulcsot idézőjelek vagy aposztrófok közé kell tenni tömbbeli elemre történő hivatkozásnál, például: $ize['bigyo'] és nem $ize[bigyo]. Vajon miért nem jó $ize[bigyo] alak? Talán láttad ezt a szintaxist régi PHP programokban:
Ez hibás, és mégis működik. Akkor mégis miért nem jó? Azért, mert a bigyo itt valójában egy nem definiált állandót jelöl, és nem a 'bigyo' sztringet (figyelj az aposztrófokra). A későbbi PHP verziókban már előfodulhatnak olyan előre definiált állandók, amelyeknek ugyanaz lesz a neve, mint ami a saját kódodban sztringként szerepel. Azért működik, mert ezeket a csupasz stringeket (idézőjel nélküli string, amelyeknek nem felel meg egy ismert szimbólum) a PHP a nevükkel azonos tartalmú sztringgé konvertálja. Például nincs definiálva bigyo nevű konstans, ezért a PHP helyettesíteni fogja a 'bigyo' stringgel.Megjegyzés: Ez nem azt jelenti, hogy mindig idézőjelek közé kellene raknod a kulcsot. Ne használj idézőjelet, amikor a kulcs konstans vagy változó, mivel ez megakadályozná a PHP-t abban hogy ezeket értelmezze.
<?php error_reporting(E_ALL); ini_set('display_errors', true); ini_set('html_errors', false); // Egyszerű tömb: $array = array(1, 2); $count = count($array); for ($i = 0; $i < $count; $i++) { echo "\n$i vizsgálata: \n"; echo "Rossz: " . $array['$i'] . "\n"; echo "Jó: " . $array[$i] . "\n"; echo "Rossz: {$array['$i']}\n"; echo "Jó: {$array[$i]}\n"; } ?>Megjegyzés: A fenti példa a következő kimenetet adja:
Több példa ennek megmutatására:
<?php
// Irassunk ki minden hibát
error_reporting(E_ALL);
$arr = array('gyümölcs' => 'alma', 'zöldség' => 'répa');
// Helyes
print $arr['gyümölcs']; // alma
print $arr['zöldség']; // répa
// Helytelen. Működik de E_NOTICE szintű hibát ad,
// mert nincs gyümölcs nevű konstans definiálva
//
// Notice: Use of undefined constant gyümölcs - assumed 'gyümölcs' in...
print $arr[gyümölcs]; // alma
// Definiáljunk egy konstanst, hogy lássuk mi folyik itt.
// A gyümölcs nevű konstanshoz a 'zöldség' értéket rendeljük.
define('gyümölcs', 'zöldség');
// Notice the difference now
print $arr['gyümölcs']; // alma
print $arr[gyümölcs]; // répa
// A következő rendben van, mert string belsejében van.
// A konstansokat nem keresi stringen belül, tehát itt nincs E_NOTICE
print "Hello $arr[gyümölcs]"; // Hello alma
// Kivétel: a stringben kapcsos zárójelekkel körülvett tömbök
// esetén figyeli a konstansokat
print "Hello {$arr[gyümölcs]}"; // Hello répa
print "Hello {$arr['gyümölcs']}"; // Hello alma
// Ez nem működik, szintaktikai hibát eredményez, mint például:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Ez természetesen szuperglobális tömbök esetén is érvényes.
print "Hello $arr['gyümölcs']";
print "Hello $_GET['ize']";
// Egy másik lehetőség az összefűzés (konkatenáció)
print "Hello " . $arr['gyümölcs']; // Hello alma
?> |
Ha beállítod az error_reporting()-ot hogy írja ki az E_NOTICE szintű hibákat (vagy ha E_ALL-ra állítod), akkor látni fogod ezeket a hibákat. Alapértelmezésben az error_reporting úgy van beállítva, hogy ezeket ne mutassa.
Ahogy a szintaxisról szóló részben tárgyaltuk, a szögletes zárójelek között ('[' and ']') kifejezés kell álljon. Ez azt jelenti, hogy írhatsz ilyeneket is:
Ez a példa bemutatja, hogyan használhatsz függvény visszatérési értéket tömbindexként. A PHP úgyszintén ismeri a konstansokat. Bizonyára hallottál már az E_* konstansokról.<?php $hiba_leiras[E_ERROR] = "Fatális hiba történt"; $hiba_leiras[E_WARNING] = "A PHP figyelmeztetést adott"; $hiba_leiras[E_NOTICE] = "Informális megjegyzés"; ?> |
<?php $hiba_leiras[1] = "Fatális hiba történt"; $hiba_leiras[2] = "A PHP figyelmeztetést adott"; $hiba_leiras[8] = "Informális megjegyzés"; ?> |
As we already explained in the above examples, $ize[bigyo] still works but is wrong. It works, because bigyo is due to its syntax expected to be a constant expression. However, in this case no constant with the name bigyo exists. PHP now assumes that you meant bigyo literally, as the string "bigyo", but that you forgot to write the quotes.
Valamikor a jövőben a PHP fejlesztői hozzáadhatnak egy új konstanst vagy kulcsszót a nyelvhez, vagy bevezethetsz egy új konstanst az alkalmazásodba, és akkor bajba kerülsz. Például jelenleg sem használhatóak az empty és default szavak, mivel ezek speciális kulcsszavak.
Ha ezek az érvek nem győznek meg: ez a szintaxis egyszerűen nem javasolt, és bármikor megszűnhet működni.
Megjegyzés: Mint ahogy említettük, a dupla-idézőjelekkel megadott string-ben helyes, ha a tömbindexet nem veszed körül idézőjelekkel, így a "$ize[bigyo]" helyes. Részletekért lásd a fenti példákat, valamint a változók behelyettesítése című részt.
Ha az integer, float, string, boolean vagy resource típusokat konvertálod tömbbé (array), egyelemű tömböt kapsz eredményül (indexe 0), amely az eredeti elem értékét tartalmazza.
Ha objektumot konvertálsz tömbbé, a tömb elemei az objektum attribútumai lesznek, a kulcsok pedig a megfelelő attribűtumok nevei lesznek.
Ha a NULL értéket konvertálod tömbbé, üres tömböt kapsz eredményül.
Lehetőség van a tömbök összehasonlítására. Erre használhatod a array_diff() függvényt valamint a tömb operátorokat.
A tömb típus a PHP-ben nagyon sokoldalú, ezért összegyűjtöttünk néhány példát, hogy megmutassuk a tömbök erejét.
<?php
// ez
$a = array( 'szín' => 'piros',
'íz' => 'édes',
'alak' => 'kerek',
'név' => 'alma',
4 // 0 lesz a kulcsa
);
// teljesen megyezik ezzel
$a['szín'] = 'piros';
$a['íz'] = 'édes';
$a['alak'] = 'kerek';
$a['név'] = 'alma';
$a[] = 4; // 0 lesz a kulcsa
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// a következő tömböt adja: array(0 => 'a', 1 => 'b', 2 => 'c')
// vagy egyszerűen: array('a', 'b', 'c')
?> |
Példa 11-6. Az array() használata
|
Figyelj arra, hogy jelenleg közvetlenül nem lehet módosítani a tömb elemeinek értékét ezzel a ciklussal. A problémát a következőképpen tudod megkerülni:
Példa 11-8. Kollekció
A fenti példa a következő kimenetet adja:
|
Ebben a példában egy egytől számozott tömböt készítünk.
A tömbök rendezettek. A sorrendet számos függvénnyel megváltoztathatod. Lásd a tömb függvények című részt további információkért. A tömbben szereplő elemek számát a count() függvénnyel tudod lekérdezni.
Mivel a tömb egy értéke bármi lehet, értékként akár egy másik tömböt is megadhatsz. Ilyen formában készíthetsz rekurzív vagy többdimenziós tömböket.
Példa 11-12. Rekurzív és többdimenziós tömbök
|
Jegyezd meg, hogy tömb értékül adása mindig másolást jelent. Használd a referencia operátort, ha a tömböt referencia szerint szeretnéd átadni.
Egy objektum létrehozására a new operátor való, amely az adott objektumtípus egy példányát hivatott létrehozni [mivel lehet, hogy hivatkozni akarunk rá, rendszerint másolni szoktuk az objektumot (ill. a címét) egy változóba]
<?php
class semmi // egy objektumosztály létrehozása, semmi az osztály neve
{
function do_semmi ()
{
echo "Csinálom a semmit.";
}
}
$bigyo = new semmi; // $bigyo most egy semmi típusú objektum
$bigyo->do_semmi(); // a $bigyo objektum do_semmi()
// metódusát (függvényét) hívja
?> |
Alaposabb információkért nézd meg az Osztályok és objektumok című részt.
Ha egy objektumot konvertálsz objektummá, nem változik meg. Ha más típusú értéket konvertálsz objektummá, akkor létrejön egy új példány keletkezik a beépített stdClass osztályból. Ha az érték NULL volt, az új példány üres lesz. Minden más érték esetén egy scalar nevű attribútum fogja tartalmazni az értéket.
Az erőforrás egy olyan speciális változó, ami egy külső erőforrásra tartalmaz referenciát. Az erőforrásokat speciális függvények hozzák létre és használják. Lásd az ide tartozó függeléket a különböző erőforrás típusokhoz tartozó függvények listájával.
Megjegyzés: Az erőforrás típus a PHP 4-ben került a nyelvbe.
Lásd még a get_resource_type() függvényt.
Mivel az erőforrások speciális azonosítók amelyek nyitott állományokra, adatbázis-kapcsolatokra, képvászon-területekre és hasonlókra mutatnak, nem konvertálhatsz bármilyen értéket erőforrássá.
A PHP 4-es Zend Engine-jében bevezetett hivatkozás-számlálási technika következtében a használatlan erőforrásokat automatikusan detektálja a PHP (mint a Java). Ebben az esetben minden erőforrás által használt összes más erőforrás felszabadításra kerül a szemétgyűjtő algoritmusban. Emiatt ritkán szükséges, hogy felszabadítsuk a foglalt memóríát valamilyen free_result jellegű függvénnyel.
Megjegyzés: Az állandó adatbázis kapcsolatok speciálisak abban az értelemben, hogy nem szűnnek meg a szemétgyűjtés során. Lásd még az állandó kapcsolatok című részt.
A speciális NULL érték jelzi, hogy egy változó nem tartalmaz értéket. A NULL a NULL egyetlen lehetséges értéke.
Megjegyzés: A NULL típus a PHP 4-ben került bevezetésre.
Egy változó NULL-nak tekintendő, ha
a NULL állandó értéke lett hozzárendelve.
ha még semmilyen érték nem lett hozzárendelve.
ha az unset() függvény törölte.
A mixed olyan paramétert jelöl, amely több típust elfogad (de nem feltétlenül bármit).
Például a gettype() bármilyen típust elfogad, viszont a str_replace() csak stringet és tömböt fogad el.
Egyes függvények, mint például a call_user_func() vagy a usort() felhasználó által definiált "visszahívható" függvényt fogad el paraméterként. A visszahívható függvények nemcsak egyszerű függvények lehetnek, hanem objektum-metódusok vagy statikus osztály-metódusok.
A PHP függvénynek csak egyszerűen át kell adni a nevét. Bármilyen beépített vagy felhasználó által definiált függvényt megadhatsz kivéva a következőket: array(), echo(), empty(), eval(), exit(), isset(), list(), print() és unset().
Egy objektum-metódust tömbként kell megadni úgy, hogy a 0 indexű elem az objektumot tartalmazza, az 1 indexű elem pedig a metódus nevét.
Statikus osztálymetódusok is átadhatók anélkül, hogy példányosítanánk. Ebben az esetben a 0 indexnél az osztály nevét kell megadni objektum helyett.
Példa 11-13. Példák visszahívható függvény használatára
|
A PHP nem követeli meg (nem támogatja) az explicit típusdefiníciót a változók deklalárásakor; egy változó típusát a környezet határozza meg, amiben a változót használjuk. Vagyis ha egy stringet rendelünk $var-hoz, akkor $var string lesz. Ha ezután egy egészet rendelünk hozzá, $var egész lesz.
Egy példa a PHP automatikus típuskonverziójára az összeadás '+' operátora. Ha bármely operandusa lebegőpontos, akkor mindegyik operandusból lebegőpontos lesz, és az eredmény is az lesz. Máskülönben, ha az operandusok egészek, az eredmény is egész lesz. Figyeljünk azonban arra, hogy az operandusok típusát NEM változtatja meg; csupán a kiértékelés módját határozza meg.
<?php $ize = "0"; // $ize egy string (ASCII 48) $ize += 2; // $ize most egész (2) $ize = $ize + 1.3; // $ize most lebegőpontos (3.3) $ize = 5 + "10 Kis Pingvin"; // $ize egész (15) $ize = 5 + "10 Kismalac"; // $ize egész (15) ?> |
Ha az utolsó két példa furcsának tűnik, nézd meg a String konvertálása számmá című részt.
Ha egy változót adott típussal szeretnél használni egy kifejezésben, nézd meg a Típus konverziókat. Ha a változó típusát akarod megváltoztatni, használd a settype() függvényt.
Ha az ebben a fejezetben található példákat ki szeretnéd próbálni, használd a var_dump() függvényt a típusok és értékek kiírására.
Megjegyzés: Egy tömb típusának automatikus konverziója jelenleg nem definiált.
Mivel a PHP (történeti okokból) támogatja, hogy a stringet, mint karakterek tömbjét kezeljük, és "beleindexeljünk" a fenti példa problémához vezet: $a-ból most tömb legyen, aminek az eleme "f", vagy a string első karaktere legyen "f"?
Több információért lásd a String karaktereinek elérése és módosítása című részt.
A PHP jelen verziói a második értékadást string offszet meghatározásaként értelmezik, így az $a értéke "f" lesz, mindamellet, hogy ennek a konverziónak az eredményét határozatlannak tekintjük. A PHP 4 bevezette a kapcsos zárójeles szintaxist a string karaktereinek elérésére, használd ezt a szintaxist a fent bemutatott helyett.
PHP-ben a típuskonverzió úgy működik, mint C-ben: a kívánt típus nevét zárójelbe írjuk az elé a változó elé, amelyet cast-olni (konvertálni) akarunk.
A megengedett típusok:
(int), (integer) - egésszé konvertál
(bool), (boolean) - logikai értékké konvertál
(real), (double), (float) - lebegőpontos számmá konvertál
(string) - stringgé konvertál
(array) - tömbbé konvertál
(object) - objektummá konvertál
Megjegyzés: szóközök és tabulátorok megengedettek a string belsejében, tehát az alábbiak ugyanazt csinálják:
Megjegyzés: Egy változót úgy is striggé konvertálhatsz, hogy dupla idézőjelek közé teszed.
Nem mindig tiszta, hogy mi történik, ha típusok közt cast-olunk [implicit cast]. További információkért lásd az alábbi fejezeteket:
PHP-ban a változókat egy dollárjel utáni változónév jelöli. A változónevek érzékenyek kis- és nagybetűk különbözőségére.
A változónevekre a PHP más jelzőivel azonos szabályok vonatkoznak. Egy érvényes változónév betűvel vagy aláhúzással kezdődik, amit tetszőleges számú betű, szám vagy aláhúzás követ. Reguláris kifejezéssel kifejezve ez a következőt jelenti: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
Megjegyzés: Ebben az esetben egy betű lehet az angol abc egy betűje a-z-ig és A-Z-ig, valamint a 127-től 255-ig terjedő (0x7f-0xff) ASCII kódú karakterek.
Lásd még a Változókkal kapcsolatos függvényeket.
<?php $var = 'Géza'; $Var = 'János'; echo "$var, $Var"; // kiírja, hogy "Géza, János" $4site = 'ez nem jó'; // nem érvényes, mert számmal kezdődik $_4site = 'ez ok'; // érvényes, aláhúzással kezdődik $täyte = 'mansikka'; // érvényes, az 'ä' a kiterjesztett ASCII 228-as karaktere $tükörfúrógép = 'árvíztűrő'; // érvényes, ellenőrizheted egy ASCII táblában ?> |
PHP 3-ban a változókhoz mindig értékek tartoznak. Vagyis ha egy kifejezést rendelünk egy változóhoz, az eredeti kifejezés egészének értéke másolódik a célváltozóba. Ez azt jelenti, hogy ha például egy változó értékét egy másikhoz rendeljük, egyikük megváltozása sincs hatással a másikra. Nézd át Kifejezések c. fejezetet, ahol az ilyen jellegű hozzárendelésekről több információ található.
PHP 4-től lehetőség van egy másik hozzárendelési módra: változó referencia szerinti hozzárendelésére. Ez azt jelenti, hogy az új változó egyszerűen hivatkozik (más szóval "alias lesz", vagy "rá mutat") az eredetire. Az új változón végzett változtatások az eredetit is érintik és fordítva. Ez azt is jelenti, hogy nem történik másolás; ekképpen a hozzárendelés gyorsabban történik meg. Igaz ugyan, hogy ez a sebességnövekedés csak "feszes" ciklusokban vagy nagy tömböknél ill. objektumok átadásakor jelentkezik.
Referencia szerinti értékadáshoz egyszerűen & jelet kell az átadandó változó neve elé írni. Az alábbi kód - például - kiírja kétszer, hogy 'Nevem Bob':
<?php $ize = 'Bob'; // 'Bob' hozzárendelése $ize-hoz $bigyo = &$ize; // Hivatkozás $ize-ra $bigyo-ban. $bigyo = "Nevem $bigyo"; // $bigyo megváltoztatása... echo $bigyo; echo $ize; // $ize is megváltozott ?> |
Fontos megjegyezni, hogy csak megnevezett változókra lehet referenciát létrehozni.
A PHP egy számos előre definiált változót biztosít az bármely futó szkript számára. Sokat ezek közül nem lehet teljes pontossságal dokumentálni, mert függnek a a futtató szervertől, a használt verziótól, a konfigurálástól, és egyéb tényezőktől. Néhány ilyen változó nem elérhető, ha a PHP parancssorból fut. Ezen változókról találsz egy listát Fenntartott előredefiniált változók c. részben.
| Figyelem |
A PHP 4.2.0 és későbbi verzióiban a register_globals direktíva alapértelmezett értéke off. Ez a PHP-nek egy jelentős változása. A register_globals off-ra állítása befolyásolja az előredefiniált változók készletét a globális hatáskörben. Például a DOCUMENT_ROOT lekéréséhez a $_SERVER['DOCUMENT_ROOT'] formát kell használnod $DOCUMENT_ROOT helyett, vagy http://www.pelda.hu/teszt.php?id=3 URL esetén $_GET['id']-t az $id helyett, vagy $_ENV['HOME'] alakot a $HOME helyett. Több információért olvasd el a register_globals-ról szóló bejegyzést, a biztonságról szóló fejezetben a Register Globals használatáról szóló részt, valamint a PHP 4.1.0 és 4.2.0 verzióinak bejelentését. A PHP-ben rendelkezésre álló fenntartott előredefiniált változók, mint például a szuperglobális tömbök használata ajánlottabb. |
A 4.1.0-s verziótól a PHP további előredefiniált tömböket biztosít, amelyek webszerverektől (ha van), környezetből, és felhasználótól származó változókat tartalmaznak. Ezek az új tömbök elég sajátosak, mivel automatikusan globálisak, azaz automatikusan rendelkezésre állnak minden hatáskörben. Ezért gyakran nevezik ezeket 'autoglobálisn' vagy 'szuperglobális' tömböknek. (A felhasználónak nincs lehetősége szuperglobális változók definiálására.) A szuperglobális tömbök alább vannak felsorolva; viszont a PHP előredefiniált változóinak tartalma és természetüknek tárgyalása a Fenntartott előredefiniált változók című részben olvasható, ahol a régebbi előredefiniált változók ($HTTP_*_VARS) létezéséről is tudomást szerezhetsz. Az 5.0.0 változattól kezdődően az előre definiált hosszú PHP változók létrehozása kikapcsolható a register_long_arrays direktíva segítségével.
Változó változók: A szuperglobális változók nem használhatók változó változókként függvényekben és osztályok metódusaiban.
Megjegyzés: Annak ellenére, hogy egyidőben létezhet a szuperglobális és a HTTP_*_VARS tömb, ezen nem azonosak, tehát az egyiknek a módosítása nem változtatja meg a másikat is.
Ha bizonyos változók nincsenek megjelölve a variables_order-ben akkor a megfelelő PHP előredefiniált tömbök üresek.
PHP szuperglobális változók
Minden olyan változóhoz tartalmaz egy referenciát, amely pillanatnyilag a szkript globális hatáskörében létezik. Ennek a tömbnek a kulcsai a globális változók nevei. A $GLOBALS tömb a PHP 3-tól létezik.
Olyan változók amelyeket a webszerver állított be vagy amelyek szorosan összefüggenek a szkript futtatási környezetével. Analógiája a régebbi $HTTP_SERVER_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott).
HTTP GET kérés által létrejövő változók. Analógiája a régebbi $HTTP_GET_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott).
HTTP POST kérés által létrejövő változók. Analógiája a régebbi $HTTP_POST_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott).
HTTP sütikből (cookie) származó változók. Analógiája a régebbi $HTTP_COOKIE_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott).
HTTP post fájlfeltöltés által létrejövő változók. Analógiája a régebbi $HTTP_POST_FILES tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott). További információ a POST típusú fájlfeltöltésről szóló fejezetben.
A környezetből származó változók. Analógiája a régebbi $HTTP_ENV_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott).
HTTP GET, POST és COOKIE bementekből származó változók, azaz amelyekben nem lehet megbízni. A jelenléte és a változók tömbbe való besorolásának sorrendje a PHP variables_order konfigurációs direktívája szerint van definiálva. Ennek nincs közvetlen analógiája a PHP 4.1.0-nál előbbi verzióiban. Lásd még: import_request_variables().
| Figyelem |
A PHP 4.3.0 óta a $_FILES-ban szereplő fájlinformációk nem szerepelnek a $_REQUEST-ben. |
Megjegyzés: Parancssori futtatás esetén ez nem tartalmazza az argv and argc bejegyzéseket; ezek a $_SERVER tömbben szerepelnek.
Olyan változók, amelyek a szkript munkamanetéhez vannak rendelve. Analógiája a régebbi $HTTP_SESSION_VARS tömbnek (amely még mindig rendelkezésre áll, de használata nem ajánlott). További információért lásd a Munkamenet kezelő függvények című részt.
[Ezt a fejezetet érdemes elolvasni, még akkor is, ha profi vagy valamilyen programozási nyelvben, mert a PHP tartogat egy-két érdekes meglepetést...]
A változó hatásköre az a környezet, amelyben a változó definiált. A legtöbb esetben minden PHP változónak egyetlen hatásköre van. Ez az egyetlen hatáskör kiterjed az include és a require segítségével használt fájlokra is. Például:
Itt az $a változó elérhető lesz az beillesztett b.inc szkriptben is. A felhasználói függvényekkel a lokális függvényhatáskör kerül bevezetésre. Alapértelmezés szerint minden, függvényen belül használt változó ebbe a lokális függvényhatáskörbe tartozik, például:
<?php
$a = 1; /* globális hatáskör */
function Test ()
{
echo $a; /* egy helyi változót vár */
}
Test();
?> |
Ez a szkript nem fog semmilyen kimenetet sem eredményezni, mivel az echo kifejezés az $a változónak egy helyi - függvényen belüli - változatára utal, és ebben a hatáskörben ehhez nem rendeltek értéket. Ez valamelyest különbözik a C nyelv filozófiájától, ahol a globális változók automatikusan elérhetők bármely függvényből, feltéve ha a függvényben újra nem definiáltad azt a változót. Ez problémák forrása lehet, ha az ember véletlenül megváltoztat egy globális változót. A PHP-ben a globális változókat global kulcsszóval kell deklarálni a függvényekben.
Először nézzünk egy példát a global használatára:
A fenti szkript kiírja, hogy "3". $a és $b global-ként való deklarálásával minden utalás ezekre a változókra a globális változót fogja érinteni. Nincs megkötve, hány globális változót kezelhet egy függvény.
Globális változók elérésének másik módja a PHP által definiált speciális $GLOBALS tömb használata. Az előbbi példával egyenértékű megoldás:
A $GLOBALS asszociatív tömb, ahol a globális változó neve jelenti a kulcsot, és a változó értéke a tömbelem értéke. Vedd észre, hogy a $GLOBALS tömb minden hatáskörben létezik, mivel a $GLOBALS egy szuperglobális változó. A következő példa a szuperglobális változók erejét szemlélteti.
Példa 12-3. Példa szuperglobális változók és a hatáskör szemléltetésére
|
A változók hatáskörének másik fontos lehetősége a static (statikus) változó. A statikus változó csak lokális hatáskörben él - egy függvényen belül, de két függvényhívás közt nem veszti el az értékét, a változó hatásköréből való kilépés esetén is megmarad az értéke:
Ez nagyon haszontalan függvény, mivel nem csinál mást, mint minden meghívásakor $a-t 0-ra állítja, aztán kiírja a 0-t. Az $a++ teljesen felesleges, mert amint vége a függvény futásának az $a változó megszűnik. Ahhoz, hogy ebből értelmes számlálófüggvény legyen - megmaradjon a számláló értéke -, az $a változót statikusnak kell deklarálni:
Most már valahányszor meghívódik a Test() függvény, kiírja $a értékét, majd azt megnöveli eggyel.
A statikus változókat a rekurzív függvények megvalósításában is felhasználhatjuk. Rekurzívnak nevezzük azt a függvényt, amely saját magát hívja meg. Ezt természetesen feltételhez kell kötni, nehogy végtelen rekurzióba kerüljön a vezérlés és meghatározatlan időre a függvényen belül csapdába esik. Mindig meg kell bizonyosodni arról, hogy megfelelő feltétel rendelkezésre áll a rekurzió befejezéséhez. A következő függvény rekurzívan elszámol 10-ig a statikus $count változó segítségével: [A static kulcsszó nagyon fontos!]
Megjegyzés: Statikus változókat a fenti példákban szereplő módon lehet deklarálni. Ha olyan értéket próbálsz értékül adni neki, amely egy kifejezés eredménye, az parse error-t fog okozni.
A PHP 4-et működtető Zend Engine 1, a statikus és globális változó módosítókat referenciákkal implementálja. Például egy valódi globális változó beemelve egy függvény hatáskörébe a global utasítással tulajdonképpen létrehoz egy referenciát a globális változóhoz. Ez váratlan viselkedésmódhoz vezethet, amelyet a következő példa illusztrál:
<?php
function test_global_ref() {
global $obj;
$obj = &new stdclass;
}
function test_global_noref() {
global $obj;
$obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?> |
A példában szereplő kód végrahajtása a következő kimenetet produkálja:
NULL
object(stdClass)(0) {
} |
Hasonló viselkedésmód jellemzi a static utasítást. A referenciák nem statikusan vannak tárolva:
<?php
function &get_instance_ref() {
static $obj;
echo 'Statikus objektum: ';
var_dump($obj);
if (!isset($obj)) {
// Hozzárendel egy referenciát a statikus változóhoz
$obj = &new stdclass;
}
$obj->property++;
return $obj;
}
function &get_instance_noref() {
static $obj;
echo 'Statikus objektum: ';
var_dump($obj);
if (!isset($obj)) {
// Hozzárendeli az objektumot a statikus változóhoz
$obj = new stdclass;
}
$obj->property++;
return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?> |
A példa végrehajtása a következő kimenetet eredményezi:
Statikus objektum: NULL
Statikus objektum: NULL
Statikus objektum: NULL
Statikus objektum: object(stdClass)(1) {
["property"]=>
int(1)
} |
A példa azt szemlélteti, hogy amikor hozzárendelsz egy referenciát egy statikus változóhoz, az nem lesz megjegyezve amikor újra meghívod a &get_instance_ref() függvényt.
Néha kényelmes változó változók használata. Ez olyan változó jelent, amelynek a nevét dinamikusan lehet beállítani. A normál változót így adunk értéket:
A változó változó veszi egy változó értékét, amelyet egy másik változó értékének tekinti. A fenti példában a hello, egy változó neveként használható, a $a elé még egy $-t írva.
Ekkor már két változó van a PHP szimbólumtáblájában: $a, amelynek tartalma "hello", és $hello, amelynek a tartalma "világ". Ennélfogva a következő programsor:
pontosan ugyanazt csinálja, mintha ezt írtuk volna:
Mindkettő kiírja, hogy: hello világ.
Annak érdekében, hogy változó változókat tömbökkel együtt is használhassuk, fel kell oldani a következő kétértelműséget. A $$a[1] kifejezés kiértékelésekor a feldolgozónak tudnia kell, hogy ez a $a[1] értékét tekintse a hivatkozott változó neveként, vagy $$a-t - és ekkor és ennek a tömbnek 1. indexű elemére történt a hivatkozás. Az első esetben ${$a[1]}, míg a másodikban ${$a}[1] írandó.
| Figyelem |
Jó, ha észben tartod, hogy változó változókat nem használhatsz a PHP szuperglobális tömbjeivel függvényekben és osztályeljárásokban. |
Egy HTML űrlap (form) elküldésével az űrlapból származó összes adat automatikusan elérhetővé válik a szkript számára a PHP segítségével. Többféle mód létezik ezen információk elérésére:
Az egyéni beállításaidtól függően több mód is létezik HTML formok által beküldött adatok elérésére. Íme néhány példa:
Példa 12-9. Egy egyszerű HTML POST űrlapból származó adatok elérése
|
Egy GET form használata hasonló, kivéve hogy a megfelelő GET előredefiniált változókat kell használnod. A GET a QUERY_STRING-re vonatkozik (az információ, ami az URL-ben a '?' után szerepel). Például a http://www.pelda.hu/teszt.php?azon=3 tartalmaz egy GET adatot, amely $_GET['azon'] módon érhető el. Lásd még: $_REQUEST, import_request_variables()
Megjegyzés: A szuperglobális tömbök, mint például a $_POST vagy a $_GET, a PHP 4.1.0-től állnak rendelkezésre.
Mint láttuk, a PHP 4.2.0 előtt a register_globals alapértelmezett értéke on volt, PHP 3-ban pedig mindig be volt állítva. A PHP közösség azt javasolja mindenkinek, hogy ne alapozzon erre a direktívára, mert az off-ra állítását sokkal inkább részesítík előnyben; ennek megfelelően érdemes programozni.
Megjegyzés: A magic_quotes_gpc konfigurációs beállítás hatással van a GET, POST és COOKIE metódusokkal kapott értékekre. Bekapcsolva a (Ez a "PHP", biz'a!) szövegből automágikusan (Ez a \"PHP\", biz\'a!) lesz, hogy megkönnyítse az adatbázisba írást. Lásd még: addslashes(), stripslashes() és magic_quotes_sybase!
A PHP megérti és kezeli a tömbökbe rendezett űrlapváltozókat. (Lásd kapcsolódó Gy.I.K.!) Hasznos lehet csoportosítani az összetartozó változókat, vagy az olyan űrlapelemeket, ahol több lehetőség közül nem csak egy választható. Példaképpen küldjünk el egy űrlapot saját magának, és elküldéskor jelenítsük meg az adatot.
Példa 12-10. Összetettebb űrlapváltozók
|
PHP 3-ban ilyen módon csak egydimenziós tömbök hozhatók létre, míg PHP 4-től nincs ilyen korlátozás.
Az űrlap elküldésekor megoldható, hogy gomb helyett képet használunk ilyesféle jelölés segítségével:
Ha a felhasználó a képre kattint, a kiszolgálóra a következő két változó jut el: elkuld_x-et és elkuld_y-t. Ezek tartalmazzák a kattintás képen belüli koordinátáit. A tapasztaltabbak biztos megjegyeznék, hogy a változónevek nem aláhúzást, hanem pontot tartalmaznak, de a PHP a pontot automatikusan aláhúzássá konvertálja.
A PHP támogatja a Netscape specifikációja által definiált HTTP sütiket. A süti olyan mechanizmus, amely a távoli böngészőn tesz lehetővé adattárolást, és így lehetővé teszi a visszatérő felhasználók azonosítását. A sütiket a setcookie() függvénnyel lehet beállítani. A sütik a HTTP fejléc részei, így a SetCookie függvényt bármilyen kimenet generálása előtt kell meghívni. Ugyanezt a megkötést kell betartani a header() függvénnyel. A süti adatok a megfelelő tömbökben találhatóak, mint például a $_COOKIE, $HTTP_COOKIE_VARS valamint a $_REQUEST. További részleteket és példákat a kézikönyv setcookie() oldalán találsz.
Ha több adatot akarsz rendelni egy sütiváltozóhoz, egyszerűen tekintsd egy tömbnek. Például:
<?php
setcookie("Sutikem[ize]", 'Teszt 1', time()+3600);
setcookie("Sutikem[bigyo]", 'Teszt 2', time()+3600);
?> |
Ez két különböző süti, viszont a szkriptedben a Sutikem egyetlen tömb lesz. Ha egy sütiben szeretnél tárolni összetett adatokat, használhatod a serialize() vagy az explode() függvényeket.
Vigyázz, mert a süti felülírja az előző azonos nevű sütit, hacsak nem különbözik a path vagy a domain. Így pl. egy bevásárlókocsi megírásakor jó egy számlálót is elhelyezni, hogy elkerüljük a problémát.
Példa 12-11. Példa a setcookie() használatára
|
Általában a PHP nem változtatja meg a változók neveit, amikor a szkript megkapja őket. A pont viszont nem érvényes karakter egy PHP változóneven belül. Az ok megértéséért nézd ezt:
<?php $varname.ext; /* érvénytelen változónév */ ?> |
Emiatt fontos, hogy PHP automatikusan helyettesíti a pontokat aláhúzásjellel.
Mivel a PHP határozza meg a változók típusát és konvertálja őket (általában) szükség szerint, nem mindig nyilvánvaló, hogy milyen típusú egy pillanatban egy adott változó. A PHP-nek számos függvénye van, amelyek egy változó típusát hivatottak eldönteni, mint például: gettype(), is_array(), is_float(), is_int(), is_object(), és is_string(). Lásd még a típusokról szóló fejezetet.
Az állandó egy skalár érték azonosítója (neve). Mint ahogy az elnevezése is mutatja, a program futása során nem változik/hat meg az értéke. Kivételt képeznek a mágikus konstansok, amelyek tulajdonképpen nem is konstansok. Az állandók alapesetben érzékenyek a kis- és nagybetűs irásmódra. Megállapodás szerint általában csupa nagybetűs neveket használunk az állandók neveiként.
Az állandók neveire a PHP más jelzőivel azonos szabályok vonatkoznak. Egy érvényes állandó-név betűvel vagy aláhúzással kezdődik, amit tetszőleges számú betű, szám vagy aláhúzás követ. Reguláris kifejezéssel kifejezve ez a következőt jelenti: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
Példa 13-1. Helyes és helytelen konstans nevek
|
Megjegyzés: Ebben az esetben egy betű lehet az angol abc egy betűje a-z-ig és A-Z-ig, valamint a 127-től 255-ig terjedő (0x7f-0xff) ASCII kódú karakterek.
Hasonlóan a szuperglobális változókhoz, az állandók bárhonnan elérhetőek. Az aktuális hatáskörtől (scope) függetlenül bárhol használhatók. A változók hatásköre című részben tobbet megtudhatsz a hatáskörökről.
A define() függvénnyel lehet állandót létrehozni, amelynek definiálása után később nem lehet törölni vagy megváltoztatni az értékét.
Csak skaláris adat (boolean, integer, float vagy string típusú) lehet egy konstans tartalma.
A konstans értékére a nevének megadásával lehet hivatkozni. A változókkal ellentétben nem szabad $ jelet tenned a konstand neve elé. Egy konstans értékének lekérésére használhatod még a constant() függvényt is, abban az esetben, ha a konstans nevét dinamikusan szeretnéd megkapni. A get_defined_constants() függvénnyel lehet a definiált konstansok listáját megkapni.
Megjegyzés: A konstansok és a (globális) változók különböző névtérben vannak. Ez azt jelenti, hogy a TRUE és a $TRUE két különböző dolgot jelent.
Ha egy definiálatlan konstanst próbálsz meg használni, a PHP a konstans nevét veszi karaktersorozatként értékül (KONSTANS és "KONSTANS"). Ilyen esetekben egy E_NOTICE szintű hiba keletkezik. Lásd még a kézikönyvnek azt a részét, ahol azt tárgyalja, miért nem jó az $ize[bigyo] használata, abban az esetben, ha előtte nem definiáltad a bigyo-t konstansként. Ha szeretnéd megtudni, hogy egy konstans definiálva van, használd a defined() függvényt.
A következők a fontosabb különbségek a változókhoz képest:
Az állandók nevét nem kell dollár jellel $ kezdeni.
Az állandók akárhol definiálhatók, és akárhonnan elérhetők, a változók környezeti korlátozásaitól függetlenül.
Az állandók nem módosíthatóak, és nem törölhetőek, miután egyszer létrehozták azokat.
Az állandók csak skaláris értékeket tartalmazhatnak.
A PHP számos előredefiniált állandót biztosít a szkripteknek. Ezek többnyire a különböző kiterjesztések által meghatározott állandók, és csak akkor léteznek, ha az adott kiterjesztés is elérhető/használható akár dinamikusan betöltve vagy előre befordítva.
5 mágikus konstans létezik, amelyek változnak aszerint, hogy hol használják. Például a __LINE__ értéke attól függ, hogy a szkript melyik sorában használják. Ezek a speciális állandók nem érzékenyek a kis- és nagybetűkre.
Táblázat 13-1. Néhány "mágikus" konstans
| Név | Leírás |
|---|---|
| __LINE__ | A fájl aktuális sorának száma. |
| __FILE__ | Az állomány teljes elérési útvonala és neve. Ha include-al beillesztett fájlban használod, a beillesztett fájl nevét tartalmazza. A PHP 4.0.2 óta a __FILE__ mindig az abszolút útvonalat tartalmazza, míg a régebbi verziókban egyes esetekben a relatív útvonalat tartalmazta. |
| __FUNCTION__ | A függvény neve. (A PHP 4.3.0-ban került a nyelvbe.) A PHP 5-től a függvény nevét olyan formában adja meg, ahogy deklarálva volt (figyelembe veszi a kis- és nagybetűket). PHP 4-ben csupa kisbetűvel adja meg a függvény nevét. |
| __CLASS__ | Az osztály neve. (A PHP 4.3.0-ban került a nyelvbe.) A PHP 5-től az osztály nevét olyan formában adja meg, ahogy deklarálva volt (figyelembe veszi a kis- és nagybetűket). PHP 4-ben csupa kisbetűvel adja meg az osztály nevét. |
| __METHOD__ | Az osztály metódusának neve. (PHP 5.0.0-ban került a nyelvbe.) A metódus nevét olyan formában adja meg, ahogy deklarálva volt (figyelembe veszi a kis- és nagybetűket). |
Lásd még a get_class(), get_object_vars(), file_exists() és function_exists() függvényeket.
A kifejezések a PHP legfontosabb építőkövei. A PHP-ban majdnem minden, amit leírsz, egy kifejezés. A lehető legegyszerűbb és mégis pontos definíciója a kifejezésnek: "mindaz, amelynek értéke van".
A kifejezések legalapvetőbb formái az állandók és a változók. Az "$a = 5" az '5'-öt az $a változóhoz rendeli. Az '5'-nek nyilván 5 az értéke, vagyis más szavakkal az '5' olyan kifejezés, melynek értéke 5 (itt az '5' egy egész típusú állandó).
Ez után a hozzárendelés után $a értéke 5 kell legyen, sőt, $b = $a esetén az eredménynek azonosnak kell lennie azzal, mint $b = 5 esetén. Másképp megfogalmazva az $a olyan kifejezés, amelynek értéke 5. Ha minden jól megy, pontosan ez fog történni.
Kissé bonyolultabb példák a kifejezésekre a függvények. Például tekintsük az alábbi függvényt:
Megelőlegezzük, hogy nem idegen Tőled a függvények koncepciója - ha nem így lenne, akkor olvasd el a függvényekről szóló fejezetet. Amint az elvárható, a $c = foo() lényegében azonos $c = 5 beírásával. A függvények olyan kifejezések, amelyeknek az értéke a visszatérési értékük. Mivel foo() 5-tel tér vissza, a 'foo()' kifejezés értéke 5. Általában a függvények nem arra használatosak, hogy egy bedrótozott számmal térjenek vissza, hanem valamilyen számolt származtatott értékkel.
Természetesen a változóknak a PHP-ben nem kell egésznek lenniük, és nagyon gyakran nem is azok. A PHP négy féle skalártípust támogat: egész (integer), lebegőpontos (float), sztring (string) és logikai (boolean) értékeket (skalárnak az számít, amit nem lehet kisebb darabokra bontani, eltérően - például - a tömböktől). A PHP két nem skalár típust is támogat: a tömb és objektum típust. Mindegyikükhöz lehet értéket rendelni, és mindegyikük lehet egy függvény visszatérési értéke.
A PHP továbbfejleszti a kifejezés fogalmát, ahogy azt sok hasonló nyelv teszi. A PHP egy kifejezés-orientált nyelv, abból a szempontból, hogy majdnem minden kifejezés. Tekintsük a példát, amivel eddig foglalkoztunk: '$a = 5'. Látható, hogy két értéket szerepel benne: az egész konstans '5' és $a értéke, amelyet az 5 értékkel frissítettünk. Az igazság azonban az, hogy még egy érték is van a kifejezésben, a magáé a hozzárendelésé. A hozzárendelés maga kiértékeli az átadandó értéket, ebben az esetben az 5-öt. Ez azt jelenti gyakorlatilag, hogy a '$a=5', a hatásától eltekintve egy kifejezés, amelynek az értéke 5. Ha ezért olyasmit írunk, hogy '$b=($a=5)', akkor az olyasmi, mintha '$a=5; $b=5;'-t írtunk volna (a pontosvessző jelöli az állítás végét). Mivel a hozzárendelés jobbról balra történik, ez írható zárójelek nélkül is: '$b=$a=5'.
A kifejezés-orientáltság másik jó példája az elő- és utónövekményes operátor. A PHP használóinak és sok más nyelvet használónak ismerős lehet a változó++ és változó-- jelölés. Ezek a növelő és csökkentő operátorok. A PHP/FI 2-ben a '$a++'-nek nincs értéke (mert nem kifejezés), és ezért nem is lehet semmihez hozzárendelni, vagy valamire használni. A PHP kiterjesztette az inkrementálás/dekrementálás lehetőségeit azzal, hogy ezeket is kifejezésekké alakította, mint ahogyan a C nyelvben is megtették. A PHP-ben a C nyelvhez hasonlóan kétféle növekményes operátor van: elő- és utó(növekményes). Mindkettő megnöveli a változó értékét, tehát a változó szempontjából nézve nincs különbség, a kifejezés értékében annál inkább. A '++$változó' formájú előnövekményes a megnövelt értéket adja vissza. (A PHP először növeli a változót, majd kiértékeli, innen jön az 'elő'). A '$változó++' alakú utónövekményes a változó eredeti értéket adja. (A PHP először kiértékeli, aztán növeli a változót, innen jön az 'utó'). [A csökkentő operátorokkal értelemszerűen ugyanez a helyzet.]
A kifejezések egy gyakori típusai az összehasonlító kifejezések. Ezen kifejezéseknek az értékei FALSE vagy TRUE. A PHP támogatja a > (nagyobb), >= (nagyobb, vagy egyenlő), == (egyenlő), != (nem egyenlő), < (kisebb) és a <= (kisebb, vagy egyenlő) operátorokat. A nyelv támogat még néhány szigorú ekvivalencia operátort: === (egyenlő és azonos típusú) és !== (nem egyenlő vagy nem azonos típusú). Ezeket a kifejezéseket általában feltételes kifejezésekben szokták használni. Ilyen pl. az if kifejezés.
Az utolsó példa, amivel itt foglalkozunk, a kombinált hozzárendelés-operátor kifejezés. Már tudhatod, hogy ha $a-t eggyel szeretnéd megnövelni, akkor egyszerűen írhatod, hogy '$a++' vagy '++$a'. Mi van akkor, hogy ha nem eggyel, hanem 3-mal kell megnövelni? Lehet háromszor egymás után írni, hogy '$a++', de ez nem valami hatékony és üdvözítő megoldás. Sokkal jobb gyakorlat az '$a=$a+3' használata. Ez kiértékeli az $a + 3-at, és hozzárendeli az $a-hoz, amelynek az lesz a végső eredménye, hogy $a értéke megnő hárommal. A PHP-ben - több más C-szerű nyelvhaz hasonlóan - ennél rövidebb formában is megadható: '$a+=3'. Ez pontosan azt jelenti, hogy "vedd $a értékét, és adjál hozzá hármat, és írd vissza az eredményt $a-ba". Amellett, hogy rövidebb és érthetőbb, még gyorsabb is. '$a+=3' értéke, mint egy normál értékadásé a hozzárendelt érték. Ez persze NEM 3, hanem $a + 3 (hiszen ezt az értéket rendeltük $a-hoz). Az összes többi kétoperandusú operátort lehet ilyenformán hozzárendelő-operátorként használni, például '$a-=5' (kivon 5-öt $a-ból), '$b*=7' (megszorozza $b-t 7-tel), stb.
Létezik még egy kifejezés, amely elég különösnek tűnhet, hacsak nem láttad már más nyelvekben: a háromoperandusú feltételes operátor:
Értéke: ha az első kifejezés értéke TRUE(nem nulla), akkor a második részkifejezés, egyébként a harmadik részkifejezés. Egy segítő példa:
<php
$b = $todo == 'növel' ? $a+5 : $a-5; // $b $a+5 lesz, ha $todo értéke 'növel'
// egyébként $b $a-5 lesz
?> |
Ez megegyezik az alábbi kóddal:
Az alábbi példa segíthet az elő- és utónövekményes illetve csökkentő operátorok és kifejezéseik jobb megértésében:
<?php
function duplaz($i)
{
return $i*2;
}
$b = $a = 5; /*ötöt rendelünk $a és $b változókhoz */
$c = $a++; /* utónövekményes, $c 5 lesz, mert
először $a kiértékelődik, csak aztán nő */
$e = $d = ++$b; /* előnövekményes, $b növelt értéke (6)
adódik tovább $d-nek és $e-nek */
/* itt $d és $e hat */
$f = duplaz($d++); /* $d kétszeresének hozzárendelése mielőtt
inkrementálódik, 2*6 = 12 lesz $f */
$g = duplaz(++$e); /* $e kétszeresének hozzárendelése miután
inkrementálódik 2*7=14 lesz $g */
$h = $g += 10; /* először $g 10-zel nő, így 24 lesz az értéke,
ez adódik tovább $h-nak, az is 24 lesz*/
?> |
Egyes kifejezések tekinthetők utasításoknak. Ebben az esetben egy utasítás 'kif' ';' alakú, vagyis kifejezés utána pontosvesszővel. A '$b=$a=5;'-ben $a=5 érvényes kifejezés, de nem érvényes utasítás önmagában. A teljes '$b=$a=5;' már igen.
Még egy említésre méltó dolog a kifejezések igaz értéke. Sok esetben főleg feltételes elágazásokban és ciklusokban, nem igazán érdekes, hogy a kifejezésnek mi az értéke, csak az, hogy igaz (TRUE) vagy hamis (FALSE). A TRUE és FALSE konstansok (nevük nem függ a kis- és nagybetűs írásmódtól) a PHP két lehetséges logikai értékei. Amikor szükséges, a kifejezések automatikusan logikai értékké alakulnak. Lásd a típuskonverziókról szóló fejezetet további részletekért.
A PHP a kifejezések egy teljes és hatékony megvalósítását biztosítja, és teljes dokumentációja meghaladja e kézikönyv kereteit. A fenti példák rávilágítanak, hogy mi is az a kifejezés, és hogyan kell létrehozni hasznos kifejezéseket. A kézikönyv hátralevő részében az expr alatt egy érvényes PHP kifejezést értünk.
Az operátor egy olyan dolog, aminek adsz egy vagy több értéket (vagy szakmai nyelven: kifejezést), ami kiad egy másik értéket (úgy hogy a kapott konstrukció kifejezéssé alakuljon). Tehát úgy gondolhatsz a függvényekre és az olyan konstrukciókra, amelyek értéket adnak vissza (pl. print), mint operátorok, azokra pedig, amelyek nem adnak vissza semmit (pl. echo), mint valami másféle dolgokra.
Három féle operátor létezik. Az első fajta operátor az unáris, amely csak egy értékkel dolgozik, például a ! (a negációs operátor) vagy ++ (a növelő operátor). A második csoportot a bináris operátorok képviselik; ez a csoport foglalja magába a PHP által nyújtott operátorok közül a legtöbbet, találsz ezekről egy listát lejjebb az Operátorok precedenciája című részben.
A harmadik kategória a ternáris operátoré: ?:. Ezt arra érdemes használni, hogy válasszunk két kifejezés közül egy harmadik kifejezéstől függően, inkább mintsem két mondat vagy két végrehajtási út között. A ternáris kifejezések bezárójelezése igen jó ötlet.
Az operátorok precedenciája azt határozza meg, hogy milyen "szorosan" köt össze két kifejezést. Például az 1 + 5 * 3 kifejezésben, a kifejezés értéke 16, és nem 18, mert a szorzás operátorának, a ("*")-nak nagyobb precedenciája van, mint az összeadásénak ("+"). Zárójelek segítségével tetszőleges precedenciát lehet felállítani egy kifejezésen belül, ha szükséges. Például a (1 + 5) * 3 eredménye 18 lesz.
Az alábbi táblázat az operátorokat precedenciájuk szerint csökkenő sorrendben tartalmazza.
Táblázat 15-1. Operátorok precedenciája
| asszociativitás | operátorok | egyéb információ |
|---|---|---|
| nem köthető | new | new |
| jobbról balra | [ | array() |
| nem köthető | ++ -- | növelő/csökkentő operátorok |
| nem köthető | ! ~ - (int) (float) (string) (array) (object) @ | típusok |
| balról jobbra | * / % | aritmetikai operátorok |
| balról jobbra | + - . | aritmetikai operátorok és string operátorok |
| balról jobbra | << >> | bitorientált operátorok |
| nem köthető | < <= > >= | összehasonlító operátorok |
| nem köthető | == != === !== | összehasonlító operátorok |
| balról jobbra | & | bitorientált operátorok és referenciák |
| balról jobbra | ^ | bitorientált operátorok |
| balról jobbra | | | bitorientált operátorok |
| balról jobbra | && | logikai operátorok |
| balról jobbra | || | logikai operátorok |
| balról jobbra | ? : | a ternáris operátor |
| jobbról balra | = += -= *= /= .= %= &= |= ^= <<= >>= | értékadó operátorok |
| balról jobbra | and | logikai operátorok |
| balról jobbra | xor | logikai operátorok |
| balról jobbra | or | logikai operátorok |
| balról jobbra | , | sokféle használat |
[Az asszociativitás talán megér egy kis magyarázatot. Ez azt határozza meg, hogy az adott szinten levő operátorok egymás utáni, zárójel nélküli használatát hogyan értelmezi a fordító. Egy példán keresztül talán érthetőbbé válik: 1-2+3 értelmezhető (1-2)+3-nak (= 2), vagy 1-(2+3)-nak (= -4). Az előbbi kiértékelés, amely balról jobbra asszociatív, a helyes ebben az esetben. A második kiértékelés pedig jobbról balra asszociatív - ilyen lenne például a hatványozás, amely nincs a nyelvben implementálva (erre szolgál pow()). Ha a ** lenne a hatványozás, akkor a 2**3**2 helyesen 2 a 9-en = 512 lenne. Vannak nem köthető (nem asszociatív) operátorok is, ilyenek az összehasonlító operátorok. A PHP-ban tehát nem értelmes a 2<$x<4 kifejezés.]
A balról jobbra asszociativitás azt jelenti, hogy a kifejezés kiértékelése balról jobbra történik, a jobbról balra pedig ennek az fordítottját.
Megjegyzés: Annak ellenére, hogy a ! operátornak nagyobb a precedenciája, mint a = operátornak, a PHP elfogadja az ehhez hasonló kifejezéseket is: if (!$a = ize()), ebben az esetben az ize() által visszaadott érték $a-ba kerül bele.
Emlékszel az elemi aritmetikára a suliból? Ezek pont úgy működnek, mint ott.
Táblázat 15-2. Aritmetikai operátorok
| Példa | Név | Eredmény |
|---|---|---|
| -$a | Negáció | $a ellentettje |
| $a + $b | Összeadás | $a és $b összege |
| $a - $b | Kivonás | $a és $b különbsége |
| $a * $b | Szorzás | $a és $b szorzata |
| $a / $b | Osztás | $a és $b hányadosa |
| $a % $b | Modulus | $a / $b maradéka |
Az osztás operátor ("/") mindig lebegőpontos számot ad eredményül, mégha mindkét operandus egész típusú vagy egész típusúvá alakított string.
Megjegyzés: Ha az $a negatív, akkor az $a % $b maradék is negatív lesz.
Lásd még a kézikönyv matematikai függvényekről szóló oldalát.
Az alapvető hozzárendelő operátor az "=". Elsőre azt hihetnénk, hogy ez az "egyenlő valamivel" jele. Valójában azt jelenti, hogy a bal oldali operandus [ami az egyenlőségjel bal oldalán áll] a jobb oldali kifejezést kapja értékül.
A hozzárendelő kifejezés értéke a bal oldalhoz rendelt érték. Vagyis a "$a = 3" értéke 3. Ez lehetőséget ad néhány trükkös dologra:
Az alapvető hozzárendelő operátoron felül vannak ún. "kombinált" operátorok is az összes kétoperandusú aritmetikai és sztring operátorok számára, amelyek lehetővé teszik, hogy használjunk egy változót egy kifejezésben, majd rögtön be is állítsuk a változót a kifejezés értékére. Például:
<?php $a = 3; $a += 5; // $a-t 8-ra állítja, mintha $a = $a + 5;-öt írtunk volna $b = "Csecs "; $b .= "Emő"; // $b "Csecs Emő" lesz, egyenértékű párja: $b = $b . "Emő"; ?> |
A hozzárendelés az eredeti változót az újba másolja érték szerint, így az egyiken elvégzett változtatások a másikat nem érintik. Ezt fontos tudni, például egy sokszor végrehajtott ciklus belsejében nagy tömbök másolásakor. A PHP 4 óta használható a $var =&$othervar; szintaxisú referencia szerinti érték hozzárendelés is, de ez PHP 3-ban nem működik. A 'referencia szerinti értékhozzárendelés' azt jelenti, hogy mindkét változó ugyanarra az adatra fog mutatni, és nem történik meg a változó értékének lemásolása. További információkat a referenciákról a Referenciák részletesen című fejezetben olvashatsz.
A bitorientált operátorok teszik lehetővé, hogy egész típusú számokon belül bizonyos biteket beállítsunk, vagy lefedjünk (maszkolás). Ha viszont az opertáron mindkét oldalán sztring típusú változó áll, akkor a bitorientált operátorok a sztringek karakterein dolgoznak úgy, hogy a karakterek ASCII kódjain végzik el a műveletet, és az eredményül adódó számot ASCII kóddal megadott karakternek értelmezi.
<?php
echo 12 ^ 9; // '5' -öt ír ki
echo "12" ^ "9"; // kiírja a visszaperjel karaktert (ASCII #8), mert
// ('1' (ASCII #49)) ^ ('9' (ASCII #57)) = (ASCII #8)
echo "hallo" ^ "hello"; // eredmény: #0 #4 #0 #0 #0
// 'a' ^ 'e' = #4
?> |
Táblázat 15-3. Bitorientált operátorok
| Példa | Név | Eredmény |
|---|---|---|
| $a & $b | És | Ott lesz '1' az eredményben, ahol $a és $b mindegyikében az a bit '1'-es. Minden más biten '0'. |
| $a | $b | Vagy | Ott lesz '1' az eredményben, ahol $a és $b közül legalább az egyik azon a bitje '1'-es. Minden más biten '0'. |
| $a ^ $b | Kizáró vagy | Ott lesz '1' az eredményben, ahol $a és $b közül csakis pontosan az egyikben '1' állt. Minden más biten '0'. [Más közelítésben ott lesz '1' az eredményben, ahol különböző bitek álltak $a-ban és $b-ben; megint más közelítésben $a azon bitjei invertálódnak, amely helyeken $b-ben '1' áll] |
| ~ $a | Nem | $a összes bitjét invertálja |
| $a << $b | Eltolás balra | $a bitjeit $b számú bittel balra tolja (minden bitnyi eltolás 2-vel való szorzást jelent [amíg el nem fogynak a bitek, utolsó helyen előjelbit van ?!]) |
| $a >> $b | Eltolás jobbra | $a bitjeit $b számú bittel jobbra tolja (minden bitnyi eltolás 2-vel való egész-osztást jelent. [Vigyázz, negatív számot inkább ne tolj jobbra!]) |
| Figyelem |
32 bites rendszeren ne végezz 32 bitnyinél nagyobb jobbratolást. Ne végezz balratolást olyankor, amikor az 32 bitnél hosszabb számot eredményezne. |
Az összehasonlító operátorok, mint nevük is sugallja, két érték összehasonlítására szolgálnak. Érdekesek lehetnek még a típus összehasonlítási táblázat, mivel mutat néhány példát különböző típusok összehasonlítására.
Táblázat 15-4. Összehasonlító operátorok
| Példa | Név | Eredmény |
|---|---|---|
| $a == $b | Egyenlő | Igaz (TRUE), ha $a és $b értéke egyenlő |
| $a === $b | Azonos | Igaz (TRUE), ha $a és $b értéke egyenlő, és azonos típusúak (PHP 4-től) |
| $a != $b | Nem egyenlő | Igaz (TRUE), ha $a és $b értékei különbözők |
| $a <> $b | Nem egyenlő | Igaz (TRUE), ha $a és $b értékei különbözők |
| $a !== $b | Nem azonos | Igaz (TRUE), ha $a és $b értékei vagy típusai különbözők (csak PHP 4-től) |
| $a < $b | Kisebb mint | Igaz (TRUE), ha $a szigorúan kisebb, mint $b |
| $a > $b | Nagyobb mint | Igaz (TRUE), ha $a szigorúan nagyobb, mint $b |
| $a <= $b | Kisebb, vagy egyenlő | Igaz (TRUE), ha $a kisebb, vagy egyenlő, mint $b |
| $a >= $b | Nagyobb, vagy egyenlő | Igaz (TRUE), ha $a nagyobb, vagy egyenlő, mint $b |
Ha egészet hasonlítasz stringgel, a string előbb számmá konvertálódik. Ha két számot reprezentáló stringet hasonlítasz össze, egész számokként lesznek összehasonlítva. Ezek a szabályok a switch utasítás esetén is érvényesek.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // nem éri el az "a"-t, mert egyezett 0-val
echo "a";
break;
}
?> |
Ha az operandusok típusa különböző, akkor az összehasonlítás az alábbi táblázat alapján történik (sorrendben).
Táblázat 15-5. Különböző típusú összehasonlítása
| Első operandus típusa | Második operandus típusa | Eredmény |
|---|---|---|
| null vagy string | string | NULL konvertálása ""-é, numerikus vagy lexikális összehasonlítás |
| bool vagy null | bármi | Konvertálás bool-lá, FALSE < TRUE |
| objektum | objektum | A beépített osztályok definiálhatják saját összehasonlítási módot, különböző osztályok összehasonlíthatatlanok, azonos osztályok esetén a tulajdonságokat a tömbökhöz hasonló módon hasonlítja össze |
| string, erőforrás vagy numerikus | string, erőforrás vagy numerikus | A stringek és erőforr'sok átalakulnak számokká, majd a szokásos matematikai összehasonlítás |
| tömb | tömb | A kisebb elemszámú tömb a kisebb, ha az első operandus kulcsa nem létezik a második operandusban, akkor a tömbök összehasonlíthatatlanok, egyébként a értékről értékre történő összehasonlítás következik (lásd a lenti példát) |
| tömb | bármi | A tömb mindig nagyobb |
| objektum | bármi | Az objektum mindig nagyobb |
Példa 15-2. A standard tömbösszehasonlítás másolata
|
Lásd még: strcasecmp(), strcmp(), tömboperátorok, típusok.
Egy másik feltételes operátor a "?:" (ternáris) operátor.
Példa 15-3. Alapértelmezett érték beállítása
|
Megjegyzés: A ternáris operátor egy kifejezést alkot, ezért kiértékelése nem egy változót ad, hanem egy értéket. Ez azért fontos, mert ha egy változót referencia szerint akarsz átadni, és a return $var == 42 ? $a : $b; alakot használod, a referencia szerinti átadás nem fog működni és az újabb PHP verziók esetén figyelmeztetést is kapsz.
A PHP egy hibakezelő operátort támogat, az at jelet (@ - kukac). PHP kifejezés elé írva a kifejezés által esetlegesen generált hibaüzenete(ke)t figyelmen kívül hagyja a rendszer.
Ha a track_errors szolgáltatás be van kapcsolva, bármilyen a kifejezés által generált hibaüzenet a $php_errormsg változóba kerül tárolásra. Ez a változó minden hiba esetén felülíródik, ezért használható információk kinyerése érdekében a kifejezést követően ezt minél hamarabb ellenőrizni kell.
<?php
/* Szándékos állomány megnyitási hiba */
$file = @file ('nem_letezo_allomany') or
die ("Nem lehet megnyitni, a hiba: '$php_errormsg'");
// bármilyen kifejezésre működik, nem csak függvényekre
$ertek = @$tomb[$kulcs];
// nem ad notice szintű hibát, ha a $kulcs kulcs nem létezik
?> |
Megjegyzés: A @ operátor csak kifejezésekre működik. Egyszerű ökölszabályként alkalmazandó, ha valaminek az értelmezett az értéke, akkor az elé a @ operátor is oda tehető. Ekképpen például használható változók, függvények és include() hívások, állandók neve előtt és sok más esetben. Nem használható azonban függvény és osztály definíciók vagy nyelvi szerkezetek (mint például if és foreach utasítások) előtt.
Lásd még: error_reporting(), valamint a Hibakezelő és naplózó függvényeket.
| Figyelem |
Jelenleg a "@" hibakezelő operátor kikapcsolja azon kritikus hibák jelentését is, amelyek megszakítják a szkript futását. Más problémák mellett, ha függvényből érkező hibaüzenetek elnyelésére használod a "@" jelet, le fog állni a szkript futása, ha nem létezik a megadott függvény vagy elírtad annak nevét. |
A PHP-ban létezik egy program-végrehajtó operátor: a visszaidézőjel (backtick) [aki tudja az igazi nevét, ne rejtse véka alá!] (``). Ezek nem szimpla idézőjelek! A PHP megpróbálja a sztring tartalmát parancssorból futtatandó utasításként végrehajtani, amelynek a kimenete lesz az operátor értéke. Ez nem egyszerűen a kimenetre kerül, hanem hozzárendelhető egy változóhoz. A visszaidézőjel (backtick) operátor azonos a shell_exec() függvénnyel.
[Az alábbi kis példa az aktuális könyvtár tartalmát (hosszú lista, rejtett fájlok is) formázva írja ki (fix szélességű betűket használva, újsor karaktereket tiszteletben tartva)]
Megjegyzés: A végrehajtó operátor nem használható, ha a safe mode be van kapcsolva vagy amikor a shell_exec() függvény le van tiltva.
Lásd még a kézikönyv Programfuttató függvények című részét, popen() proc_open() függvényeket, valamint a Parancssori programozás a PHP-ben című fejezetet.
A PHP támogatja a C-szerű ún. elő- és utónövekményes ill. csökkentő operátorokat.
Táblázat 15-6. Növelő/csökkentő operátorok
| Példa | Név | Hatás |
|---|---|---|
| ++$a | előnövekményes | Növeli $a-t eggyel, majd visszaadja $a értékét |
| $a++ | utónövekményes | Visszaadja $a értékét, majd növeli $a-t eggyel |
| --$a | előcsökkentő | Csökkenti $a-t eggyel, majd visszaadja $a értékét |
| $a-- | utócsökkentő | Visszaadja $a értékét, majd csökkenti $a-t eggyel |
Itt egy egyszerű példaprogram:
<?php echo "<h3>Utónövekményes</h3>"; $a = 5; echo "5-nek kell lennie: " . $a++ . "<br />\n"; echo "6-nak kell lennie: " . $a . "<br />\n"; echo "<h3>Előnövekményes</h3>"; $a = 5; echo "6-nak kell lennie: " . ++$a . "<br />\n"; echo "6-nak kell lennie: " . $a . "<br />\n"; echo "<h3>Előcsökkentő</h3>"; $a = 5; echo "5-nek kell lennie: " . $a-- . "<br />\n"; echo "4-nek kell lennie: " . $a . "<br />\n"; echo "<h3>Utócsökkentő</h3>"; $a = 5; echo "4-nek kell lennie: " . --$a . "<br />\n"; echo "4-nek kell lennie: " . $a . "<br />\n"; ?> |
Aritemtikai műveletek karakterváltozókon való végzésénél a PHP a Perl szabályait követi, és nem a C szabályait. Például a Perlben 'Z'+1 kifejezé értéke 'AA' lesz, a C-ben pedig 'Z'+1 értéke '[' ( ord('Z') == 90, ord('[') == 91 ). Megjegyzés: a karakterváltozók növelhetőek, de nem csökkenthetőek.
Boolean változók növelésének, csökkentésének nincs hatása.
Táblázat 15-7. Logikai operátorok
| Példa | Név | Eredmény |
|---|---|---|
| $a and $b | És | Pontosan akkor igaz (TRUE), ha mind $a mind $b igazak (TRUE). |
| $a or $b | Vagy | Pontosan akkor igaz (TRUE), ha $a és $b között van igaz (TRUE). |
| $a xor $b | Kizáró vagy | Pontosan akkor igaz (TRUE), ha $a és $b közül pontosan egy igaz (TRUE). |
| ! $a | Tagadás | Pontosan akkor igaz (TRUE), ha $a nem igaz (TRUE). |
| $a && $b | És | Pontosan akkor igaz (TRUE), ha mind $a mind $b igaz (TRUE). |
| $a || $b | Vagy | Pontosan akkor igaz (TRUE), ha $a és $b között van igaz (TRUE). |
Az "és" és a "vagy" operátorok két variációjára a magyarázat az operátorok precedenciájában van. (Lásd: Operátorok Precedenciája.)
Két string operátor van. Az egyik az összefűzés operátor ('.'), amely bal és jobb oldali operandusának összefűzöttjével tér vissza. A második az összefűző-hozzárendelő operátor ('.='), amely hozzáfűzi a jobb oldalon szereplő szöveges értéket a bal oldali operandus végéhez. Olvasd el a Hozzárendelő operátorok című részt!
<?php $a = "Para "; $b = $a . "Zita"; // most $b értéke "Para Zita" $a = "Dárdarázó "; $a .= "Vilmos"; // most $a értéke "Dárdarázó Vilmos" ?> |
Lásd még a kézikönyv Stringek és String függvények című részeit.
Táblázat 15-8. Tömb operátorok
| Példa | Név | Eredmény |
|---|---|---|
| $a + $b | Egyesítés | $a és $b egyesítése. |
| $a == $b | Egyenlő | TRUE ha $a és $b ugyanazokból az kulcs/érték párokból áll. |
| $a === $b | Azonos | TRUE ha $a és $b ugyanazokat az kulcs/érték párokat tartalmazza és ugyanolyan sorrendben |
| $a != $b | Nem egyenlő | TRUE ha $a nem egyenlő $b-vel. |
| $a <> $b | Nem egyenlő | TRUE ha $a nem egyenlő $b-vel. |
| $a !== $b | Nem azonos | TRUE ha $a nem azonos $b-vel. |
A + a jobboldali tömböt a baloldalihoz fűzi úgy, hogy az ismétlődő indexen levő elem nem írja felül az eredeti elemet.
<?php
$a = array("a" => "alma", "b" => "banán");
$b = array("a" => "körte", "b" => "eper", "c" => "cseresznye");
$c = $a + $b; // $a és $b egyesítése
echo "\$a és \$b egyesítése: \n";
var_dump($c);
$c = $b + $a; // $b és $a egyesítése
echo "\$b és \$a egyesítése: \n";
var_dump($c);
?> |
$a és $b egyesítése:
array(3) {
["a"]=>
string(4) "alma"
["b"]=>
string(5) "banán"
["c"]=>
string(10) "cseresznye"
}
$b és $a egyesítése:
array(3) {
["a"]=>
string(5) "körte"
["b"]=>
string(4) "eper"
["c"]=>
string(10) "cseresznye"
} |
Az összehasonlítás számára a tömbelemek akkor egyenlőek, ha megegyezik a kulcsuk és az értékük.
Lásd még a Tömbök és a Tömbkezelő függvények című részeket.
A PHP egyetlen típus operátora az instanceof. Az instanceof arra való, hogy megállapítsuk, hogy egy adott objektum eleme-e egy bizonyos objektum osztály.
Az instanceof operátor a PHP 5-ben került bevezetésre. Azelőtt az is_a() függvényt használták de használata ma nem ajánlott a instanceof létezése miatt.
<?php
class A { }
class B { }
$valami = new A;
if ($valami instanceof A) {
echo 'A';
}
if ($valami instanceof B) {
echo 'B';
}
?> |
Mivel $valami egy A típusú objektum, de nem B típusú csak az A-túl függő blokk fog végrehajtódni:
A |
Lásd még: get_class(), is_a().
Az összes PHP szkript utasítások sorozatából áll. Az utasítás lehet hozzárendelő utasítás, függvényhívás, ciklus, feltételes utasítás, vagy üres utasítás. Az utasítások általában pontosvesszővel végződnek. Ezenkívül az utasításokat csoportosítani lehet; utasításblokkba foglalhatók kapcsos zárójelek segítségével. Az utasításblokkok maguk is utasítások. A különféle utasítástípusokat ebben a fejezetben tárgyaljuk.
Az if szerkezet az egyik legfontosabb szerkezete a legtöbb nyelvnek - így a PHP-nek is. A PHP a C-ben megismerthez hasonló if szerkezettel bír:
Amint a kifejezésekről szóló fejezetben szerepel, a kifejezés logikai értéke értékelődik ki. Ha kifejezés TRUE, akkor a PHP végrehajtja az utasítást; ha FALSE, akkkor figyelmen kívül hagyja. Arról, hogy mely értékek tekinthetők FALSE-nak, a Logikai értékké alakítás c. fejezetben olvashatsz.
Az alábbi példa kiírja, hogy a nagyobb, mint b, ha $a nagyobb, mint $b:
Gyakran sok utasítást kell feltételhez kötve végrehajtani. Természetesen nem kell minden utasításhoz külön if-et írni. Az utasításokat utasításblokkba lehet összefogni. Az alábbi kód például kiírja, hogy a nagyobb, mint b ha $a nagyobb, mint $b, és utána hozzárendeli $a értékét $b-hez:
A feltételes utasítások vég nélkül további if utasításokba ágyazhatók, amely a program különböző részeinek feltételes végrehajtását igen hatékonnyá teszi.
Gyakori, hogy egy bizonyos feltétel teljesülése esetén valamilyen utasítást kell végrehajtani, és valamilyen másik utasítást, ha nem teljesül a feltétel. Erre való az else. Az else kibővíti az if utasítást, hogy akkor hajtson végre utasítást, amikor az if kifejezés FALSE-ként értékelődik ki. Az alábbi kód például kiírja, hogy a nagyobb, mint b ha $a $b-nél nagyobb, egyébként az a NEM nagyobb, mint b üzenetet írja ki:
Az else utasítás csak akkor hajtódik végre, ha az if kifejezés és az összes elseif kifejezés is FALSE értékű. Az elseif -ről most olvashatsz.Az elseif, amint azt a neve is sugallja, az if és az else kombinációja. [perlesek figyelem, itt elseif-nek hívják!!!] Az else-hez hasonlóan az if utasítást terjeszti ki, hogy különböző utasításokat hajtson végre abban az esetben, ha az eredeti if kifejezés értéke FALSE lenne. Azonban az else-sel ellentétben csak akkor hajtra végre az alternatív kódrészt, ha az elseif kifejezés TRUE. Az alábbi kód például - $a értékétől függően - üdvözli Menő Manót, és Víz Eleket, vagy kiírja, hogy ismeretlen:
<?php
if ($a == "Menő Manó") {
echo "Szervusz Menő Manó! Rég láttalak!";
} elseif ($a == 'Víz Elek') { #szimpla idézőjel is használható
echo "Üdv Víz Elek!";
} else {
echo "Szervusz, idegen. Hát téged mi szél hozott ide?";
}
?> |
Egy if kifejezést több elseif követhet. Az első olyan elseif kifejezés hajtódik végre (ha van), amely értéke TRUE. A PHP-ban az 'else if' is (különírva) használható és ugyanúgy fog viselkedni, mint az 'elseif' (egybeírva). A szintaktikai jelentés 'kicsit' eltérő (ha ismered a C-t, nos ez pont úgy működik) de végülis ugyanaz lesz a végeredmény.
Az elseif ág csak akkor hajtódik végre, ha az őt megelőző if kifejezés, és az összes köztes elseif kifejezések FALSE értékűek, de az adott elseif kifejezése TRUE.
A PHP bizonyos vezérlési szerkezeteihez egy alternatív szintaxist is nyújt; név szerint: az if, while, for, foreach, és switch számára. Minden esetben az alternatív szintaxisnál a nyitó kapcsos zárójel helyett kettőspontot (:) kell írni, a záró zárójel helyett pedig a vezérlési szerkezetnek megfelelő endif;, endwhile;, endfor;, endforeach;, vagy endswitch; utasításokat értelemszerűen.
A fenti példában az "A most éppen 5." egy alternatív szintaxisú if kifejezésbe van ágyazva. A HTML rész csak akkor íródik ki, ha $a egyenlő 5-tel.
Az alternatív szintaxis az else-re és az elseif-re is alkalmazható. Az alábbi példa egy if szerkezet, amiben van elseif és else is alternatív formában:
<?php if ($a == 0.5): echo "a most fél."; echo "De vajon kitől?"; elseif ($a == 8): echo "Nekem nyolc, hogy mennyi az a."; echo "Úgyis megváltoztatom az értékét."; $a++; else: echo "Ez így nem vicces, hogy a se nem fél, se nem nyolc"; endif; ?> |
Lásd még a while, for, és if szerkezeteket további példák reményében!
A while ciklusok a PHP legegyszerűbb ciklusai. Éppen úgy viselkednek, mint a C nyelvbeli megfelelőik. A while általános szintaxisa:
A while utasítás jelentése egyszerű. Azt mondja a PHP-nek, hogy mindaddig ismételje az utasítás(ok) végrehajtását, amíg a while kifejezés TRUE. Iterációnak nevezzük azt, amikor a PHP egyszer végrehajtja az utasítást/utasításblokkot egy ciklus részeként. A kifejezés értéke a ciklus kezdetekor értékelődik ki, tehát még ha az utasításblokk belsejében hamissá is válik a feltétel, a blokk végrehajtása akkor sem áll meg, csak az iteráció végén [feltéve ha közben megint meg nem változik a feltétel]. Amikor a while kifejezés értéke már az első vizsgálatkor FALSE, akkor az utasítás(blokk) egyszer sem kerül végrehajtásra.
Az if szerkezethez hasonlóan több utasítást csoportosítani lehet a while ciklusban kapcsos zárójelekkel, vagy az alternatív szintaxis használatával:
Az alábbi példák ugyanazt csinálják - 1-től 10-ig kiírják a számokat:
A do-while ciklusok nagyon hasonlóak a while ciklusokhoz, a különbség mindössze annyi, hogy a kifejezés igaz volta itt az iteráció végén értékelődik ki, és nem az elején. A fő különbség a hagyományos while ciklushoz képest, hogy a do-while ciklus első iterációja garantáltan lefut (a kifejezés igazságértékét csak az iteráció végén ellenőrzi), amely nem garantált a hagyományos while ciklusnál (itt a kifejezés igazságértéke az iteráció kezdetén kerül kiértékelésre, ha értéke kezdetben FALSE, akkor a ciklus végrehajtása azonnal befejeződik).
Csak egy szintaxisa van a do-while ciklusnak:
A fenti ciklus pontosan egyszer fut le, mert az első iteráció után, amikor a kifejezés igazságértéke vizsgálatra kerül, kiderül, hogy FALSE ($i nem nagyobb, mint 0) és a ciklus végrehajtása befejeződik.
Haladó C programozók már bizonyára jártasak a do-while ciklus másfajta használatában. Például utasításblokk közepén ki lehet lépni a blokkból, ha az utasításblokkot do-while (0), közé tesszük, és break utasítást használunk. A következő kódrészlet ezt szemlélteti:
<?php
do {
if ($i < 5) {
echo "i nem elég nagy";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
echo " i most jó";
/* i feldolgozása */
} while (0);
?> |
Ne aggódj, ha ezt nem azonnal vagy egyáltalán értetted meg. Lehet szkripteket - sőt hatékony szkripteket - írni ennek a lehetőségnek a használata nélkül is.
A for cilus a legbonyolultabb ciklus a PHP-ben. Éppen úgy viselkedik, mint a C nyelvbeli párja (–> C-ben értőknek tovább gomb). A for ciklus szintaxisa:
[A fenti for szerkezettel megegyező az alábbi, remélhetőleg már ismerős kifejezés:
Remélem így már érthetőbb lesz az alábbi magyarázat].Az első kifejezés (kif1) a ciklus kezdetén egyszer kerül végrehajtásra.
Minden iteráció elején kif2 kiértékelődik. Ha értéke TRUE, akkor a ciklus folytatódik, és az utasításra kerül a vezérlés. Ha értéke FALSE, akkor a ciklus véget ér.
Minden iteráció végén kif3 is végrehajtásra kerül.
Bármelyik kifejezést el lehet hagyni. Ha kif2 üres, az azt jelenti, hogy a ciklus a végtelenségig fut [hacsak nem jön a jó tündér break utasítás képében...] (A PHP implicit TRUE-nak feltételezi az üres kif2-t, mint a C.) Ez nem annyira haszontalan, mint elsőre amennyire elsőnek tűnik, hiszen gyakran fejezheted be a ciklust egy feltételes kifejezésbe ágyazott break kifejezéssel a for feltétel kifejezésének kiértékelése helyett.
Nézd az alábbi példákat, mindegyikük kiírja a számokat 1-től 10-ig:
<?php
/* téma */
for ($i = 1; $i <= 10; $i++) {
echo $i;
}
/* 1. variáció */
for ($i = 1; ; $i++) {
if ($i > 10) {
break;
}
echo $i;
}
/* 2. variáció */
$i = 1;
for (; ; ) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}
/* 3. variáció - Coda :-) */
for ($i = 1; $i <= 10; print $i, $i++);
?> |
Természetesen "a téma" a legbarátságosabb (vagy esetleg a 3. variáció). Sok helyen hasznos azonban, hogy üres kifejezés is írható for ciklusba...
A PHP a for ciklus esetén is megengedi az alternatív szintaxishasználatát:
A PHP 4-től a Perlhez és más nyelvekhez hasonlóan létezik az ún. foreach szerkezet is. Ez jól használható eszközt ad a tömbökön végzett iterációkhoz. Más típusú vagy inicializálatlan változóra nem lehet használni, azokra hibát jelez. Két szintaxisa létezik, a második egy apró, de hasznos kiegészítéssel nyújt többet az elsőhöz képest.
Az első forma végigmegy a tömb_kifejezés szolgáltatta tömbön. Minden alkalommal az aktuális elem értéke a $ertek változóba kerül, és a belső tömb mutató növelésre kerül. (A következő alkalommal tehát a soron következő elemet fogja venni).
A második forma ugyanezt végzi el, de az aktuális elem kulcsa a $kulcs változóba kerül.
A PHP 5-től kezdődően lehetséges az obejktumokon való iteráció is.
Megjegyzés: Amikor a foreach indul, a belső tömb mutató az első elemre áll. Ez azt jelenti, hogy nem kell meghívni a reset() függvényt egy foreach ciklus előtt.
Megjegyzés: Hacsak nem referenciaként adjuk meg az átnyálazandó tömböt, a foreach függvény a megadott tömb egy másolatával dolgozik és nem magával a tömbbel. Ezért az each()-el ellentétben az eredeti tömb mutatója nem változik meg, és a tömbön végzett módosítások sem kerülnek be az eredeti tömbbe. Azonban az eredeti tömb belső mutatója növelésre kerül a tömb feldolgozása során. Feltéve ha a foreach ciklus végig lefut, a tömb belső mutatója a tömb végén lesz.
A PHP 5-ös verziójától könnyedén megváltoztathatod a tömb elemeit, úgy hogy az $ertek elé egy & jelet írsz. Ez ahelyett hogy átmásolná az értéket, referenciaként adja át
Ez csak akkor lehetséges, ha a végigjárt tömb hivatkozható (azaz változó).
Megjegyzés: A foreach nem támogatja a @ hiba-elnyelő operátor használatát!
Talán már tudod, hogy az alábbi példák egyenértékűek:
<?php
$arr = array("egy", "kettő", "három");
reset($tomb);
while (list(, $ertek) = each($tomb)) {
echo "Érték: $ertek<br />\n";
}
foreach ($tomb as $ertek) {
echo "Érték: $ertek<br />\n";
}
?> |
<?php
$arr = array("egy", "kettő", "három");
reset($tomb);
while (list($kulcs, $ertek) = each($tomb)) {
echo "Kulcs: $kulcs, Érték: $ertek<br />\n";
}
foreach ($tomb as $kulcs => $ertek) {
echo "Kulcs: $kulcs, Érték: $ertek<br />\n";
}
?> |
Néhány további felhasználási példa:
<?php
/* első foreach példa: csak érték */
$tomb = array(1, 2, 3, 17);
foreach ($tomb as $ertek) {
echo "Az aktuális értéke \$tomb-nek: $ertek.\n";
}
/* második foreach példa: érték (a kulcs csak illusztráció) */
$tomb = array(1, 2, 3, 17);
$i = 0; /* csak pedagógiai okokból :) */
foreach ($tomb as $ertek) {
echo "\$tomb[$i] => $ertek.\n";
$i++;
}
/* harmadik foreach példa: kulcs és érték */
$a = array(
"egy" => 1,
"kettő" => 2,
"három" => 3,
"tizenhét" => 17
);
foreach ($tomb as $kulcs => $ertek) {
echo "\$tomb[$kulcs] => $ertek.\n";
}
/* negyedik foreach példa: többdimenziós tömb */
$a = array();
$tomb[0][0] = "a";
$tomb[0][1] = "b";
$tomb[1][0] = "y";
$tomb[1][1] = "z";
foreach ($tomb as $belsotomb) {
foreach ($belsotomb as $ertek) {
echo "$ertek\n";
}
}
/* ötödik foreach példa: dinamikus tömbök */
foreach (array(1, 2, 3, 4, 5) as $ertek) {
echo "$ertek\n";
}
?> |
A break azonnal kilép az aktuális for, foreach, while, do-while ciklusból vagy switch szerkezetből.
A break elfogad egy elhagyható szám paramétert, amely megadja, hogy hány egymásba ágyazott struktúrából kell egyszerre 'kiugrani'.
<?php
$tomb = array('egy', 'kettő', 'három', 'négy', 'stop', 'öt');
while (list (, $ertek) = each($tomb)) {
if ($ertek == 'stop') {
break; /* írhattál volna ide 'break 1;'-et is */
}
echo "$ertek<br />\n";
}
/* Az elhagyható paraméter használata */
$i = 0;
while (++$i) {
switch ($i) {
case 5:
echo "5 esetén<br />\n";
break 1; /* csak a switch-ből lép ki */
case 10:
echo "10 esetén kilépés<br />\n";
break 2; /* a switch és a while befejezése */
default:
break;
}
}
?> |
A continue ciklusok belsejében használható arra, hogy átugorjuk az aktuális iteráció hátralevő részét, és a végrehajtást a feltételkiértékeléssel, majd a következő iterációval folytassuk.
Megjegyzés: Megjegyezzük, hogy a PHP-ben a switch utasítást ciklus utasításnak tartjuk, a continue definíciója miatt.
A continue elfogad egy elhagyható szám paramétert, amely megadja, hogy hány egymásba ágyazott struktúrának a hátralévő részét kell átugrani.
<?php
while (list ($kulcs, $ertek) = each($tomb)) {
if (!($kulcs % 2)) { // a páros indexűek kihagyása
continue;
}
valami_paratlan_dolog($ertek);
}
$i = 0;
while ($i++ < 5) {
echo "Külső while<br />\n";
while (1) {
echo " Középső while<br />\n";
while (1) {
echo " Belső while<br />\n";
continue 3;
}
echo "Ezt soha nem fogja kiírni.<br />\n";
}
echo "Ezt sem...<br />\n";
}
?> |
A pontosvessző elhagyása a continue után zavarhoz vezethet. Íme egy példa arra, hogy milyen helyzet nem kellene előforduljon:
<?php
for ($i = 0; $i < 5; ++$i) {
if ($i == 2)
continue
print "$i\n";
}
?> |
Az elvárt eredmény ez lehetne:
0 1 3 4 |
de a szkript ezt fogja kiírni:
2 |
mert a print() által visszatérített érték int(1), ami úgy tűnhet, mintha a fent tárgyalt opcionális paraméter lenne.
A switch kifejezés hasonló egy sereg IF kifejezéshez, ahol a kifejezésekben ugyanaz szerepel. [Pont olyan, mint a C-ben, C-s gyakorlattal rendelkezőknek Tovább gomb]. Gyakori, hogy ugyanazt a változót (vagy kifejezést) kell összehasonlítani több különböző értékkel, és más-más kódot végrehajtani a változó (kifejezés) értékétől függően. Pontosan erre való a switch.
Megjegyzés: Néhány más nyelvvel ellentétben, a continue utasítás használható switch-ben és ugyanúgy működik mint a break. Ha van egy switch-et egy cikluson belül, és a ciklusban szeretnél továbblépni, a continue 2 parancsot kell kiadnod.
Az alábbi két példa két különböző módon írja ki ugyanazt, az egyik egy sor if utasításokat használ, a másik pedig a switch-et:
A hibák elkerülése végett fontos megérteni, hogy hogyan kerül végrehajtásra a switch szerkezet. A switch vagyis utasításról utasításra hajtódik végre. Nem hajtódik végre semmilyen utasítás, csak akkor, ha egy olyan case kifejezést talál a PHP, amely egyezik a switch kifejezés értékével. Ezután a PHP addig folytatja az utasítások végrehajtását, amíg el nem éri a switch blokk végét, vagy nem találkozik egy break utasítással. FONTOS! Ha nem nincs break egy case-hez tartozó utasítás(sorozat) végén, akkor a PHP végrehajtja a soron következő case-hez tartozó utasításokat is! Például:
Itt, ha $i értéke 0, akkor a PHP az összes kiíró utasítást végrehajtja! Ha $i értéke 1, akkor a PHP az utolsó két echo-t hajtja végre, és csak ha $i értéke 2, akkor kapod a 'kívánt' eredményt (csak az 'i most 2' íródik ki). Tehát nagyon fontos nem elfelejteni a break utasítást (bár bizonyos körülmények között lehet, hogy pont ennek elhagyása a szándékos).
A switch kifejezésben a feltétel csak egyszer értékelődik ki és a kapott eredmény lesz összehasonlítva a case kifejezések mindegyikével. Ha elseif kifejezéseket használsz, a kifejezések újra és újra kiértékelődnek. [és újra és újra be kell gépelni. Ez nem csak fárasztó, de hiba forrása is lehet.] Ha a kifejezés bonyolult, vagy egy ciklus belsejében van, a switch a gyorsabb.
Egy eset (case) utasításlistája üres is lehet, így a vezérlés a következő case-címkére adódik.
<?php
switch ($i) {
case 0:
case 1:
case 2:
echo "i 3-nál kisebb, de nem negatív";
break;
case 3:
echo "i pont 3";
}
?> |
Egy különleges eset a default [alapértelmezett] címke. Ez a címke bármivel egyezik, amivel a korábbi case elemek nem egyeztek. Ennek kell az utolsó elemnek lennie. Például:
<?php
switch ($i) {
case 0:
echo "i most 0";
break;
case 1:
echo "i most 1";
break;
case 2:
echo "i most 2";
break;
default:
echo "i se nem 0, se nem 1, se nem 2";
}
?> |
A case kifejezés tetszőleges kifejezés, aminek egyszerű a típusa, vagyis egész vagy lebegőpontos szám, vagy string. Tömbök és objektumok itt nem használhatók, csakis egy-egy elemük ill. változójuk egyszerű típusként.
Az alternatív szintaxis működik a switch-ekkel is. Bővebb információért lásd: Vezérlési szerkezetek alternatív szintaxisa.
A declare egy kódblokk számára adott futtatási direktívák beállítását teszi lehetővé. A declare szintaxisa hasonló a vezérlési szerkezetekéhez:
A direktíva rész a declare blokk működését szabályozza. Jelenleg csak egy direktíva használható, a ticks. (Lásd lejjebb a ticks részleteit)
A declare blokk utasítás része mindig egyszer fut le. Az, hogy miképp, és milyen mellékhatásokkal, a direktíva részben megadottaktól függ.
A declare konstukció globális hatáskörben is használható, ilyenkor hatással van minden utána következő kódra.
<?php
// ezek ekvivalensek:
// használhatod ezt:
declare(ticks=1) {
// entire script here
}
// vagy használhatod ezt:
declare(ticks=1);
// entire script here
?> |
A tick egy olyan esemény, amely minden N db alacsony szintű utasítás végrehajtásakor bekövetkezik a declare blokkban. Az N értéket a ticks=N szintaxissal kell megadni a declare blokk direktíva részében.
Az egyes tick-ekre bekövetkező esemény(ek) a register_tick_function() függvénnyel állítható(ak) be. Lásd az alábbi példát. Akár több esemény is bekövetkezhet egy tick-re.
Példa 16-3. A PHP kód egy részének időmérése
|
A tick-ek kiválóan alkalmasak hibakeresésre, egyszerű multitasking megvalósítására, háttérben futattott I/O-ra, és sok más feladatra.
Lásd még a register_tick_function() és az unregister_tick_function() függvényeket!
A return() utasítás függvényen belül használva azonnal befejezi a folyó függvény futását, és a paramétereként megadott érték szolgáltatja a függvény visszatérési értékét. A return() az eval() függvénnyel futatott kód vagy a szkript futását is leállítja.
A globális érvényességi körben használva a folyó szkript futását szakítja meg. Ha ez a szkript az include() vagy a require() hatására lett futtatva, akkor a vezérlés visszaadódik arra a fájlra, ahol ezek az utasítások szerepelnek, valamint include() esetén a return() paramétere lesz az include() utasítás visszatérési értéke. Ha a return() a fő szkriptben lett kiadva, akkor befejeződik a szkript futása. Ha ez a auto_prepend_file vagy auto_append_file php.ini-ben szereplő fájlok valamelyikében történik akkor, (csak) ezeknek a futása fejeződik be.
További magyarázatért lásd Visszatérési értékek c. fejezetet!
Megjegyzés: Mivel a return() nyelvi szerkezet és nem függvény, a paraméterét körülvevő zárójelek csak akkor szükségesek, ha az argumentum kifejezést tartalmaz. Általános szokás, hogy nem használják amikor egy változót térítenek vissza, különösen azért mert a PHP-nek így kevesebb munkát kell végeznie.
Megjegyzés: Return utasításban soha ne írj zárójelet a valtozó köré, ha azt referencia szerint akarod visszaadni, mert úgy nem fog működni. Referencia szerint csak változót adhatsz át, kifejezés eredményét nem. Ha return ($a); alakban írod, akkor nem a változót adod vissza, hanem a ($a) kifejezés értékét (ami természetesen az $a változó értéke).
A require() beilleszti és feldolgozza a megadott fájlt. Ennek részletes mikéntjéről, lásd include()!
A require() és az include() megegyezik egymással a hibakezelését leszámítva. Az include() nem fatális hibát, figyelmeztetést generál, a require() viszont fatális hibát jelez. Másszóval, ahol az igényelt fájl nemlétekor a futást meg kell szakítani, ajánlott a require(). Az include() nem így viselkedik, a hibától függetlenül a szkript futtatása folytatódik. Bizonyosodj meg, hogy a include_path helyesen van beállítva!
Példa 16-4. Egyszerű require() példák
|
Lásd az include() oldalát még több példáért!
Megjegyzés: PHP 4.0.2 előtt, a következők szerint működött. A require() mindig beolvasta a kívánt fájlt, még ha az a require()-t tartalmazó sorra soha nem is került vezérlés. A feltételes szerkezetek nem befolyásolták a működését. Mégis, ha a require()-t tartalmazó sorra nem került vezérlés a megadott fájlban lévő kód nem futott le. Ehhez hasonlóan, a ciklusok sem befolyásolták a működését. Habár a fájlban szereplő kód függött az azt körülölelő ciklustól, a require() maga csak egyszer történt meg.
Megjegyzés: Mivel ez egy nyelvi konstrukció és nem egy függvény, nem hívható meg a változó változók lehetőség felhasználásának segítségével.
| Figyelem |
A PHP Windows rendszeren futó verziója a 4.3.0-ásnál régebbi változataiban nem támogatja a távoli állomány elérést e függvény használatakor, még akkor sem, ha az allow_url_fopen engedélyezett. |
Lásd még: include(), require_once(), include_once(), eval(), file(), readfile() és virtual() függvényeket valamint az include_path beállítást!
Az include() beilleszti és feldolgozza a megadott fájlt.
Az alábbiak igazak a require()-ra is. A require() és az include() megegyezik egymással a hibakezelését leszámítva. Az include() nem fatális hibát, figyelmeztetést generál, a require() viszont fatális hibát jelez. Magyarán, ahol az igényelt fájl nemlétekor a futást meg kell szakítani, ajánlott a require(). Az include() nem így viselkedik, a hibától függetlenül a szkript futtatása folytatódik. Bizonyosodj meg, hogy a include_path helyesen van beállítva! Jegyezd meg, hogy a szintaktikai hiba a include()-olt fájlban nem okozza a feldolgozás megszakítását a PHP 4.3.5 verziója előtt, ettől a verziótól kezdve viszont igen.
A beillesztendő fájlokat először az aktuális könyvtárhoz viszonyított include_path-ban keresi, majd az aktuális szkript könyvtárához viszonyított include_path-ban. Például ha az include_path a ., aktuális könyvtár a /www/, beillesztetted az include/a.php-t amelyben van egy include "b.php" utasítás, a b.php-t először a /www/-ben keresi, majd a /www/include/-ban. Ha a fájlnév ../ karakterekkel kezdődik, csak aktuális munkakönyvtárhoz viszonyított include_path-ban keresi.
A fájl beillesztése során a megadott fájl örökli az include() helyén érvényes változó hatáskört. Bármely változó, amely azon a ponton elérhető, elérhető a beillesztett fájlban is. Ellenben a beillesztett fájlban szereplő függvény- és osztálydefiníciók, globális láthatósággal rendelkeznek.
Példa 16-5. Egyszerű include() példa
|
Függvény belsejében a megadott fájlban szereplő kód úgy fog viselkedni, mintha az magában a függvényben szerepelt volna. Ez azt jelenti, hogy a fájl örökli a változók érvényességi körét.
Példa 16-6. Függvényen belüli beillesztés
|
Ha egy fájlt beillesztünk az include()-dal vagy require()-ral, akkor a célfájl elején az elemző kilép a PHP módból HTML módba, majd visszaáll PHP módba a fájl végén. Ennek okán bármely beillesztendő fájlban levő PHP kódot közre kell fogni egy érvényes PHP kezdő- és zárójelöléssel.
Ha a "fopen wrappers" szolgáltatás engedélyezve van (mint például az alapértelmezett konfigurációban), a beillesztendő fájlt megadhatod URL-ként (HTTP-ként vagy más támogatott wrapperként - a protokollok listáját itt találhatod: M Függelék), ahelyett hogy helyi útvonalként adnád meg. Ha a célszerver PHP kódként feldolgozza a fájlt, akkor átadhatsz változókat a hívott fájlnak HTTP GET lekérési formában. Ez nem teljesen ugyanaz, mintha a include()-dal hívott fájl örökölné a helyi változókat, mivel a szkript valójában a távoli szerveren fut le, és a futási eredmény kerül beépítésre a helyi szkriptbe.
| Figyelem |
A PHP Windows rendszeren futó verziója a 4.3.0-ásnál régebbi változataiban nem támogatja a távoli állomány elérést e függvény használatakor, még akkor sem, ha az allow_url_fopen engedélyezett. |
Példa 16-7. include() HTTP-n keresztül
|
Mivel az include() és a require() különleges nyelvi elem, kapcsos zárójelekkel kell közrefogni, ha egy feltételes utasításon belül szerepel.
Példa 16-8. include() feltételes blokkon belül
|
return utasítást lehet elhelyezni egy include()-olt fájlban annak érdekében, hogy a kiértékelés ott befejeződjön, és visszaadjon egy értéket a hívó szkriptnek. A visszatérési értéket ugyanúgy használhatod, mint egy közönséges függvénynél. Ez azonban nem lehetséges távoli fájlok beillesztésénél, kivéve akkor, ha a távoli fájl kimenete érvényes kezdő és záró tag-ekkel rendelkezik (mint bármilyen helyi fájl). A szükséges változókat deklarálhatod a tag-ek között, és be lesznek vezetve bármely ponton ahol a fájl beillesztésre került.
Mivel az include() egy speciális nyelvi konstrukció, nem szükséges bezárójelezni az argumenumát. Vigyázz amikor a visszatérítési értékét hasonlítod.
Megjegyzés: PHP 3, a return nem jelenhet meg függvény blokkon kívül máshol, amely esetben a függvényből történő visszatérést jelöli.
$bigyo értéke 1, mert a beillesztés sikeres volt. Figyeld meg a különbséget a két fenti példa között. Az első a return() segítségével visszaadott egy értéket, a második nem. Ha nem tudja beilleszteni a fájlt, FALSE-t ad vissza és E_WARNING szintű hibát ad.
Ha a beillesztett fájlban vannak függvénydefiníciók, azokat használni lehet a fő állományban függetelenül attól, hogy a return() előtt vagy után vannak. Ha a fájl kétszer kerül beillesztésre, a PHP 5 fatális hibát ad, mivel a függvények már deklarálva voltak. A PHP 4 nem panaszkodik miattuk a return() után definiált függvények miatt. Ajánlott a include_once() használata, ahelyett hogy a beillesztett fájlban vizsgáld, hogy már be volt-e illesztve és ez esetben return-al kilépjél.
Egy másik módja a PHP fájlok beemelésének a kimenet elfogása a kimenet szabályzó függvények és az include() használatával.
Példa 16-11. PHP file kimenetének stringbe gyűjtése kimenetszabályozás használatával
|
Az automatikus fájlbeillesztéssel kapcsolatban lásd a auto_prepend_file és a auto_append_file php.ini konfigurációs beállításokat.
Megjegyzés: Mivel ez egy nyelvi konstrukció és nem egy függvény, nem hívható meg a változó változók lehetőség felhasználásának segítségével.
Lásd még a require(), require_once(), include_once(), readfile() és virtual() függvényeket!
Az require_once() beilleszt és feldolgoz fájlokat a program futása közben. Ez hasonló az require() működéséhez, azzal a fontos különbséggel, hogy ha a már egyszer beillesztésre került kódot a PHP nem próbálja meg ismét betölteni.
A require_once() használatos azokban az esetekben, amikor ugyanaz a fájl esetleg többször kerülhet beillesztésre a szkript futása során, de biztosítani kell, hogy ez ténylegesen csak egyszer történjen meg, így megelőzve a függvények újradefiniálását, változók értékének átállítását, stb.
További példákhoz az require_once() és include_once() használatához nézd meg a PEAR kódot, ami a legfrissebb PHP disztribúciókban megtalálható.
A visszatérítési értékek ugyanolyanok mint az include() esetében. Ha a fájl már egyszer be volt illesztve, ez a függvény TRUE-t ad vissza.
Megjegyzés: A require_once() PHP 4.0.1pl2 verzióban került a nyelvbe.
Megjegyzés: Különös figyelemmel kell lenni arra, hogy hogyan viselkedik a a require_once() és a include_once() olyan operációs rendszereken, ahol az állománynevek nem nagybetűérzékenyek (mint pl. Windows)
Ez a viselkedésmód a PHP 5-ben megváltozott: az útvonalat előbb normalizálja, tehát a C:\PROGRA~1\A.php-t ugyanúgy értelmezi mint a C:\Program Files\a.php-t, és a fájlt csak egyszer require-olja.
Példa 16-12. require_once() Windows-on nagybetűérzékeny
<?php require_once("a.php"); // a.php kerül beillesztésre require_once("A.php"); // ismét a.php kerül beillesztésre pl. Windows-on! (csak PHP 4-ben) ?>
| Figyelem |
A PHP Windows rendszeren futó verziója a 4.3.0-ásnál régebbi változataiban nem támogatja a távoli állomány elérést e függvény használatakor, még akkor sem, ha az allow_url_fopen engedélyezett. |
Lásd még a include(), require(), include_once(), get_required_files(), get_included_files(), readfile() és virtual() függvényeket!
Az include_once() beilleszt és feldolgoz fájlokat a program futása közben. Ez hasonló az include() működéséhez, azzal a fontos különbséggel, hogy ha a már egyszer beillesztésre került kódot a PHP nem próbálja meg ismét betölteni.
Az include_once() használatos azokban az esetekben, amikor ugyanaz a fájl esetleg többször kerülhet beillesztésre a szkript futása során, de biztosítani kell, hogy ez ténylegesen csak egyszer történjen meg, így megelőzve a függvények újradefiniálását, változók értékének átállítását, stb.
További példákhoz az require_once() és include_once() használatához nézd meg a PEAR kódot, ami a legfrissebb PHP disztribúciókban megtalálható.
A visszatérítési értékek ugyanolyanok mint az include() esetében. Ha a fájl már egyszer be volt illesztve, ez a függvény TRUE-t ad vissza.
Megjegyzés: Az include_once() PHP 4.0.1pl2 verzióban került a nyelvbe.
Megjegyzés: Különös figyelemmel kell lenni arra, hogy hogyan viselkedik a a require_once() és a include_once() olyan operációs rendszereken, ahol az állománynevek nem nagybetűérzékenyek (mint pl. Windows)
Ez a viselkedésmód a PHP 5-ben megváltozott: az útvonalat előbb normalizálja, tehát a C:\PROGRA~1\A.php-t ugyanúgy értelmezi mint a C:\Program Files\a.php-t, és a fájlt csak egyszer include-olja.
Példa 16-13. require_once() Windows-on nagybetűérzékeny
<?php require_once("a.php"); // a.php kerül beillesztésre require_once("A.php"); // ismét a.php kerül beillesztésre pl. Windows-on! (csak PHP 4-ben) ?>
| Figyelem |
A PHP Windows rendszeren futó verziója a 4.3.0-ásnál régebbi változataiban nem támogatja a távoli állomány elérést e függvény használatakor, még akkor sem, ha az allow_url_fopen engedélyezett. |
Lásd még a include(), require(), require_once(), get_required_files(), get_included_files(), readfile() és virtual() függvényeket!
Függvényeket a következő szintaxis szerint definiálhatod:
Bármely érvényes PHP kód megjelenhet egy függvényen belül, akár még más függvény vagy osztály definíciók is.
PHP 3-ban a függvényeket definiálni kell, mielőtt hivatkozás történik rájuk (függvényhívás előtt). PHP 4-től nincs ez a megkötés, kivéve amikor egy függvény feltételesen van definiálva, mint ahogy az alábbi két példa mutatja.
When a function is defined in a conditional manner such as the two examples shown. Its definition must be processed prior to being called.
Példa 17-2. Feltételesen definiált függvények
|
Példa 17-3. Függvények függvényekben
|
Minden függvény és osztály láthatósága globális: függvényen kívülről is meghívható, akkor is ha függvényen belül definiálták, és fordítva.
A PHP nem támogatja a függvények polimorfizmusát (többalakúságát), a függvényekdefiníciókat nem lehet megszüntetni vagy már definiált függvényeket újradefiniálni.
Megjegyzés: A függvénynevek nem érzékenyek a kis- és nagybetűkre, bár rendszerint jó gyakorlat olyan formában meghívni őket, ahogyan deklaráltuk.
A PHP 3 nem támogatja a változó számú függvényargumentumokat, bár az argumentumok kezdőértéke támogatott. Lásd az Argumentumok kezdőértéke című részt bővebb információért. A PHP 4 és a későbbi változatok mindkettő lehetőséget támogatják. Lásd a Változó számú függvényargumentumok című részt és a func_num_args(), func_get_arg() és a func_get_args() függvényeket részletesebb leírásért.
PHP-ben lehetséges rekurzív függvények hívása. Kerüld azonban a 100-200 rekurziós szint elérését, mert ez felemésztheti az egész vermet, így a szkript váratlanul befejezheti a futását.
Az információ a függvényekhez az argumentumlistán keresztül jut el, ami vesszővel elválasztott kifejezések listája.
A PHP támogatja az érték szerinti (ez az alapértelmezett) referenciakénti paraméterátadást is, és az argumentumok kezdőértékét. A változó hosszúságú argumentumlisták csak a PHP 4-ben jelentek meg. Lásd a változó hosszúságú argumentumlistákat és a func_num_args(), func_get_arg() és a func_get_args() függvényeket részletesebb leírásért. PHP 3-ban hasonló hatás érhető el a függvénynek tömb típusú változó paraméterként történő átadásával:
Alapértelmezésben a függvény paraméterei érték szerint adódnak át (vagyis ha megváltoztatod a változót a függvényen belül, annak a függvényen kívülre nincs hatása). Ha szeretnéd megengedni, hogy a függvény módosítsa az átadott paramétereket, referencia szerint kell átadni azokat.
Ha egy függvényargumentum mindig referencia szerint kell átadni, akkor a függvénydefinícióban az argumentum neve elé egy & jelet kell írni.
Bármely függvény skalár-argumentumainak megadhatsz kezdőértéket a C++ szintaxisnak megfelelően:
A fenti kód kimenete:
Csinálok egy pohár cappucinot. Csinálok egy pohár espressot. |
A PHP azt is megengedi, hogy tömböt vagy a speciális NULL típust használd alapértelmezett értékként. Például:
Példa 17-8. Nem-skaláris értékek használata alapértelmezett értékként
|
A kezdőértéknek konstans kifejezésnek kell lennie, nem lehet változó, objektum vagy függvényhívás.
Figyelj arra, hogy a kezdőértékkel rendelkező argumentumok más argumentumoktól jobbra helyezkedjenek el; különben a dolgok nem úgy mennek majd, ahogy azt várnád [hanem úgy, ahogy írtad :)]. Lásd a következő kódot:
A fenti példa kimenete:
Warning: Missing argument 2 in call to joghurtot_keszit() in /usr/local/etc/httpd/htdocs/phptest/functest.php on line 41 Készítek egy köcsög ízű eper-t. |
Most hasonlítsd össze az alábbival:
A fenti példa kimenete:
Készítek egy eper ízű acidophilus-t. |
Megjegyzés: [Azért vannak kiskapuk... Az argumentumokat adjuk át egy asszociatív tömbben! Az alapértékeket pedig egy másik tömbben. Ezután vegyük végig az alapértékeket tartalmazó tömb elemeit. Ha nem definiáltak a kapott tömbben, akkor írjuk felül az alapértékeket tartalmazó tömb megfelelő elemével. Így bármelyik argumentum elhagyható, sőt még annyit is nyerünk a dolgon, hogy nem kell megjegyeznünk a paraméterek sorrendjét. (forrás: egy bő lére eresztett amerikai PHP 3 könyv)]
Megjegyzés: A PHP 5-ös változatától kezdődően a referenciaként átadott argumentumokat is el lehet látni alapértékkel.
A PHP 4 és a későbbi váltizatok támogatják a változó hosszúságú argumentumlistát a felhasználók által definiált függvényekben. Valóban nagyon egyszerű kezelni ezt a func_num_args(), func_get_arg() és a func_get_args() függvényekkel.
Semmilyen különleges szintakszist nem igényel és az argumentumlista lehet explicit módon adott és viselkedhet úgy is, mint egy normál függvény.
Az elhagyható return állítást használva adhatnak vissza értéket a függvények. Bármely típus visszaadható, beleértve a listákat és az objektumokat is. A függvény végrehajtása azonnal befejeződik, és a vezérlés visszakerül a függvényhívás utáni pozícióba. További részletes információkért lásd: return()!
Példa 17-11. A return() használata
|
Megjegyzés: [Ha nincs return, az utolsó kifejezés értékével tér viszsza a függvény]
Több értéket nem tud visszaadni a függvény, de hasonló hatás érhető el ezen többszörös értékek listába szervezésével.
Ha a függvénynek referenciával kell visszatérnie, akkor az & referencia operátort kell alkalmaznod a függvény deklarásákor és a a visszatérési érték megadásakor is.
További információkért lásd a Referenciák fejezetet!
A PHP lehetővé teszi a függvényváltozók használatát. Ha egy változónevet kerek zárójelek követnek, akkor a PHP megkeresi a változó értékével azonos nevű függvényt, és megpróbálja azt végrehajtani. Ezt többek között visszahívandó (callback) függvények vagy függvénytáblák implementálására használható.
A függvényváltozók nem fognak működni az olyan nyelvi elemekkel, mint például az echo(), print(), unset(), isset(), empty(), include(), require() és hasonlók. Ahhoz, hogy használhasd ezeket a konstrukciókat függvényváltozóként definiálnod kell saját csomagolófüggvényeket.
Példa 17-14. Függvényváltozó példa
|
Egy objektum metódusát is meghívhatod a függvényváltozókat használva.
Lásd még a call_user_func(), variable variables és function_exists() függvényeket.
A PHP rengeteg függvényt és konstrukciót biztosít. Ezen kívül vannak függvények, amelyek bizonyos lefordított PHP kiterjesztéseket igényelnek, különben "undefined function" (definiálatlan függvény) fatális hibát okoznak. Például az image függvények használatához (mint például a imagecreatetruecolor()) a PHP GD támogatással kell legyen lefordítva. Vagy a mysql_connect() használatához a PHP-be bele kell fordítani a MySQL támogatást. Sok olyan alapvető függvény van, amely minden PHP verzióban megtalálható, mint például a string és a változó függvények. A phpinfo() vagy a get_loaded_extensions() függvény kiírja mely kiterjesztések vannak betöltve a PHP-be. Sok kiterjesztés van alapértelmezésben engedélyezve. A PHP kézikönyv kiterjesztések szerint van felosztva. Egyéb információért a PHP beállításával kapcsolatban lásd még a konfiguráció, telepítés, és a kiterjesztések különálló fejezeteit.
A Hogyan értelmezzünk egy függvénydefiníciót (prototípust) című fejezetben van tárgyalva hogyan kell értelmezni a függvények kézikönyvben szereplő leírását. Fontos megérteni, hogy egy függvény mit ad vissza vagy hogy egy függvény közvetlenül az átadott értéket módosítja. Például a str_replace() a módosított karakterláncot adja vissza, miközben a usort() magán az átadott értéken dolgozik. A kézikönyvnek minden oldala sajátos információkat is tartalmaz a függvényekről, mint például a paraméterek, viselkedésmód változása, visszatérítési értékek siker és sikertelenség esetén és az információ érvényessége. Ezen fontos (viszont sokszor hajszálnyi) különbségek ismerete döntő jelentőségű lehet helyes PHP kód írásához.
Lásd még: function_exists(), teljes függvény referencia, get_extension_funcs() és dl() függvényeket.
Az osztály (objektumtípus) változók és rajtuk műveletet végző függvények [metódusok] együttese. Osztályt az alábbi szintakszis szerint lehet definiálni:
<?php
class Kosar {
var $dolgok; // A kosárban levő dolgok
// berak a kosárba $db darabot az $sorsz indexű dologból
function berak($sorsz, $db) {
$this->dolgok[$sorsz] += $db;
}
// kivesz a kosárból $db darabot az $sorsz indexű dologból
function kivesz($sorsz, $db) {
if ($this->dolgok[$sorsz] > $db) {
$this->dolgok[$sorsz] -= $db;
return true;
} elseif ($this->dolgok[$sorsz] == $db) {
unset($this->dolgok[$sorsz]);
return true;
} else {
return false;
}
}
}
?> |
Ez definiál egy Kosar nevű osztályt, ami a kosárban levő áruk asszociatív tömbjéből áll, és definiál 2 funkciót hozzá, hogy bele lehessen rakni, illetve kivenni a kosárból.
| Figyelem |
Egy osztálydefiníciót NEM szedhetsz szét több fájlra. Szintén NEM darabolhatsz egy osztálydefiníciót több PHP blokkra, hacsak nem egy metódus közepén teszed ezt valamilyen oknál fogva. A következő példakód tehát működésképtelen:
Ez viszont rendben van:
|
Az alábbi figyelmeztetések a PHP 4-es verziójára érvényesek.
| Figyelem |
Az stdClass név le van foglalva, mivel belsőleg a Zend motor használja. Emiatt nem lehet egy stdClass nevű osztályod PHP-ben. A __sleep és __wakeup nevek speciálisak a PHP osztályokban. Nem szabad ezeket a neveket használni a metódusokhoz, hacsak nem a hozzájuk tartozó speciális funkcionalitást szeretnéd felülírni. Lásd az alábbi részletes leírást. A PHP számára lefoglalt az összes __ karakterekkel kezdődő metódusnév, mint speciális név. Nem szabad __ karakterekkel kezdődő metódusnevet adni, hacsak nem a dokumentált funkciókat szeretnéd használni. |
PHP 4-ben csak állandó értékű var inicializáló értékek megengedettek. Ha nem állandó értéket szeretnél beállítani, írnod kell egy inicializáló metódust, ami automatikusan meghívódik, amikor egy objektumpéldány létrejön az osztályból. Az ilyen metódusokat hívjuk konstruktoroknak (lásd lentebb).
class Kosar {
/* Egyik alábbi értékadás sem működik PHP 4-ben */
var $mai_datum = date("Y. m. d.");
var $nev = $csaladi_nev;
var $tulajdonos = 'Ferenc ' . 'János';
/* Ámde tömböt konstans elemekkel megadhatunk */
var $termekek = array("Videó", "TV");
}
/* Így kell a fenti beállításokat elérni */
class Kosar {
var $mai_datum;
var $nev;
var $tulajdonos;
var $termekek = array("Videó", "TV");
function Kosar() {
$this->mai_nap = date("Y. m. d.");
$this->nev = $GLOBALS['csaladi_nev'];
/* stb. . . */
}
}
?> |
Az osztályok típusok, vagyis az aktuális változók tervrajzai. A kívánt típusú változót a new operátorral hozhatod létre.
<?php
$kosar = new Kosar;
$kosar->berak("10", 1);
$masik_kosar = new Kosar;
$masik_kosar->berak("0815", 3);
?> |
Ez létrehozza a Kosar objektumosztály $kosar és $masik_kosar nevű objektumpéldányait. A $kosar objektum berak() függvényét meghívtuk, hogy a 10-es számú árucikkből rakjon 1 darabot a kosárba. Három darab 0815 számú ternék került a $masik_kosar nevű kosárba.
Mind a $kosar, mind a $masik_kosar objektumoknak megvannak a berak() és kivesz() metódusai, és tulajdonságai. Ezek azonban egymástól független metódusok és tulajdonságok. Az objektumokról hasonlóan gondolkozhatsz, mint a könyvtárakról az állományrendszerben. Lehetséges, hogy két különböző OLVASSEL.TXT állományod van, ha ezek két különböző könyvtárban vannak. Úgy mint a könytáraknál, ahol meg kell adnod a teljes elérési utat, hogy egy állományra szeretnél hivatkozni a gyökérkönyvtárban, a teljes metódusnevet meg kell adnod, hogy meg tudd azt hívni. A PHP nyelvben a gyökérkönyvtár analógiája a globális környezet, és az elérési út elválasztója a ->. Ezért a $kosar->dolgok név és a $masik_kosar->dolgok név két különböző változót ad meg. Figyeld meg, hogy a változót $kosar->dolgok néven kell elérni, és nem $kosar->$dolgok néven, azaz a PHP változók neveibe csak egy dollárjelet kell tenned.
Egy osztály definiálásakor nem tudhatod, milyen néven lesz majd elérhető az objektumod a PHP programban: a Kosar osztály készítése idején nem volt ismert, hogy később $kosar vagy $masik_kosar néven nevezzük-e majd az objektumpéldányt. Ezért nem használhatod a Kosar osztályban a $kosar->dolgok hivatkozást. De hogy el tudjad érni az osztály saját metódusait és tulajdonságait az objektumpéldány nevétől függetlenül, használhatod a $this kvázi-változót, amit 'a sajátom' vagy 'az aktuális objektumpéldány' értelemben alkalmazhatsz. Ezért a '$this->dolgok[$sorsz] += $db' úgy olvasható, hogy 'adj $db darab $sorsz sorszámú terméket a saját dolgok tömbömhöz', vagy 'adj $db darab $sorsz sorszámú terméket az aktuális objektumpéldány dolgok tömbjéhez'.
Megjegyzés: A $this néven futó kvázi-változó statikusan hívott osztálymetódusok esetében nincs jelen. Ez alól kivétel az az eset, amikor statikusan hívjuk meg a metódust egy példányosított objektumon belülről. Ez esetben a $this a meghívó objektumra fog hivatkozni. Ezt mutatja be szemléletesebben az alábbi példa:
<?php class A { function ize() { if (isset($this)) { echo '$this definiálva van ('; echo get_class($this); echo ")\n"; } else { echo "\$this nincs definiálva.\n"; } } } class B { function bigyo() { A::ize(); } } $a = new A(); $a->ize(); A::ize(); $a = new B(); $b->bigyo(); B::bigyo(); ?>A fenti példa a következő kimenetet adja:
Megjegyzés: Van pár hasznos függvény az osztályok és objektumok kezeléséhez. Lásd az Osztály és objektum függvények című részt.
Gyakori, hogy szeretnél olyan osztályokat kialakítani, amelyek egy már meglévő osztályhoz hasonló tulajdonságokkal és metódusokkal rendelkeznek. Tulajdonképpen jó gyakorlat egy általános osztályt definiálni, amit minden projektedben használhatsz, és ezt az osztályt alakítani az egyes projektek igényeinek megfelelően. Ennek a megvalósítása érdekében az osztályok lehetnek más osztályok kiterjesztései. A kiterjesztett, vagy származtatott osztály minden tulajdonággal és metódussal rendelkezik, ami a kiindulási osztályban megvolt (ezt nevezzük öröklésnek, bár senki sem hal meg a folyamat során). Amit hozzáadsz a kiindulási osztályhoz, azt nevezzük kiterjesztésnek. Nem lehetséges megcsonkítani egy osztályt, azaz megszüntetni egy metódust, vagy tulajdonságot. Egy leszármazott osztály mindig pontosan egy alaposztálytól függ, azaz egyidejűéleg többszörös leszármaztatás nem támogatott. A kiterjesztés kulcsszava az 'extends'.
<?php
class Birtokolt_Kosar extends Kosar {
var $tulaj;
function tulajdonos_beallitasa($nev) {
$this->tulaj = $nev;
}
}
?> |
Ez definiál egy Birtokolt_Kosar nevű osztályt, ami a Kosar összes változójával és metódusával rendelkezik, és van egy saját változója, a $tulaj, no meg egy saját metódusa, a tulajdonos_beallitasa(). Az így gazdával ellátott kosarat a hagyományos módon hozhatod létre, és a kosár tulajdonosát is be tudod állítani, le tudod kérdezni [ebben az esetben favágó módszerrel]. A gazdás kosarakon továbbra is lehet használni a Kosar függvényeit:
<?php
// Gazdás kosár létrehozása
$gkosar = new Birtokolt_Kosar;
// a tulaj beállítása
$gkosar->tulajdonos_beallitasa("Namilesz Teosztasz");
// a tulajdonos neve
print $gkosar->tulaj;
// (Kosar-ból öröklött funkcionalitás)
$gkosar->berak("10", 1);
?> |
Ezt "szülő-gyermek" kapcsolatnak is hívják. Egy osztály akkor válik szülőosztállyá, ha más osztály létrehozásakor ezt veszik alapul az extends kulcsszó használatával. Ezzel a kiterjesztéssel definiált osztályt hívjuk gyermek-osztálynak -- ebben a kapcsolatban. Ugyanis ezek után ez a gyermekosztály is lehet más osztályok szülőosztálya, ha belőle is származtatnak egy osztályt.
Megjegyzés: Az osztálydefinicióknak a további felhasználásuk előtt rendelkezésre kell állniuk! Ha a Gazdas_Kosar-ra van szükség a Kosar kiterjesztéseként, akkor előbb a Kosar osztályt kell definiálni. Ha egy újabb osztályt származtatunk Sarga_Gazdas_Kosar néven a Gazdas_Kosar osztályból, akkor a Gazdas_Kosar osztálydefiniciónak előbb kell szerepelnie. Röviden, az osztálydefiniciók sorrendje nagyon fontos. Az osztálydefiníciókat hierarchia legfelső szintjén álló osztállyal kell kezdeni, azzal, amelyik minden más osztálynak az ősének számít (szülő vagy nagy-, déd-, ük-, szépszülő).
A konstruktorok az osztályok olyan metódusai, amelyek automatikusan meghívásra kerülnek egy új objektumpéldány new kulcsszóval történő létrehozása során. Egy függvény akkor lesz konstruktor, ha a neve megegyezik az hordozó osztály nevével. Ha az osztálynak nincs konstruktora, a szülő osytály konstruktora lesz meghívva, már ha létezik.
Ez egy olyan Auto_Kosar nevű osztályt [objektumtípust] hoz létre, mint a Kosar, csak rendelkezik egy konstruktorral, amely inicializálja a kosarat 1 darab "10"-es áruval, valahányszor a new operátorral hozzuk létre az objektumot. [de csak akkor!!!] A konstruktoroknak is lehet átadni paramétereket, és ezek lehetnek elhagyhatók is, amely még hasznosabbá teszi őket. Ha paraméterek nélkül is használható osztályt szeretnél, állíts be minden paraméternek alapértéket.
<?php
class Konstruktoros_Kosar extends Kosar {
function Konstruktoros_Kosar ($sorsz = "10", $db = 1) {
$this->berak($sorsz, $db);
}
}
// Mindig ugyanazt az uncsi dolgot veszi...
$kiindulo_kosar = new Konstruktoros_Kosar;
// Igazi vásárlás
$masik_kosar = new Konstruktoros_kosar ("20", 17);
?> |
Az @ operátor használatával elnémíthatók a konstruktorban fellépő hibák, használata ilyen esetben: @new.
<?php
class A {
function A() {
echo "Én vagyok az A osztály konstruktora.<br />\n";
}
function B() {
echo "Én egy B nevű metódus vagyok az A osztályban.<br />\n";
echo "Nem vagyok A konstruktora.<br />\n";
}
}
class B extends A {
}
// Ez meghívja B()-t, mint konstruktort
$b = new B; |
Az A osztály B() metódusa hirtelen konstruktorrá válik a B osztályban, habár ez soha sem volt cél. A PHP 4 nem foglalkozik azzal, hogy a metódus a B osztályban van-e definiálva, vagy öröklés útján áll rendelkezésre.
| Figyelem |
A PHP 4 nem hívja meg a szülő osztály konstruktorát automatikusan egy leszármazott osztály definiált konstruktorából. A te feladatod, hogy meghívd a szülő konstruktorát, ha szükséges. |
A destruktor olyan metódus, ami automatikusan meghívódik, amikor egy objektum megszűnik, akár az unset() meghívásával, akár a környezete megszűnése miatt. PHP-ben nincsenek destruktorok. Ennek pótálsaképp a legtöbb esetben jól alkalmazható a register_shutdown_function() függvény.
| Figyelem |
Az alábbiak csak PHP 4-től érvényesek. |
Időnként hasznos az ősosztályok metódusaira vagy tulajdonságaira hivatkozni, vagy olyan osztálymetódusokat meghívni, amelyek nem példányosított objektumokhoz tartoznak. A :: operátor erre használható.
<?php
class A {
function pelda() {
echo "Én az eredeti A::pelda() metódus vagyok.<br />\n";
}
}
class B extends A {
function pelda() {
echo "Én a felüldefiniáló B::pelda() metódus vagyok.<br />\n";
A::example();
}
}
// nincs semmilyen objektum az A osztályból
// ez azonban ki fogja írni:
// Én az eredeti A::pelda() metódus vagyok.<br />
A::pelda();
// B egy objektuát hozzuk létre
$b = new B;
// ez ki fogja írni:
// Én a felüldefiniáló B::pelda() metódus vagyok.<br />
// Én az eredeti A::pelda() metódus vagyok.<br />
$b->pelda();
?> |
A fenti példa meghívja az A osztály pelda() metódusát, habár nincs konkrét példányunk az A osztályból, tehát ezt nem írhatnánk le az $a->pelda()-hoz hasonlóan. Ehelyett a pelda() egy 'osztálymetódusként' viselkedik, azaz az osztály egy függvényeként, és nem egy példány metódusaként.
Osztálymetódusok léteznek, de osztálytulajdonságok (változók) nem. Mivel a hívás pillanatában semmilyen objektum nem létezik, egy osztálymetódus nem használhat objektum változókat, és egyáltalán nem használhatja a $this speciális referenciát. Egy objektummetódus azonban természetesen dolgozhat globális változókkal és lokális változókkal is.
A fenti példa a B osztályban felüldefiniálja a pelda() metódust. Az A osztálytól örökölt eredeti definíció eltűnik, és többé nem érhető el, hacsak nem az A osztályban megvalósított pelda() függvényre hivatkozol közvetlenül, a :: operátor segítségével. Ennek eléréséhez A::pelda()-t kell használni (ebben az esetben írhatnál parent::pelda()-t is, ahogy az a következő szakaszban olvasható).
Ebben a környezetben van aktuálisan használt objektum, és ennek lehetnek objektum változói (tulajdonságai). Ekképpen ha egy objektummetóduson belül használod ezt az operátort, akkor alkalmazhatod a $this-t, és felhasználhatod az objektum tulajdonságait.
Gyakran van szükség arra, hogy a szülő tulajdonságaira vagy metódusaira hivatkozzunk leszármazott osztályokban. Ez különösen igaz, ha a leszármazott osztály egy finomítása, vagy specializálása az alaposztálynak.
Ahelyett, hogy a szülő osztály nevét megadd minden ilyen meghíváskor (mint a hogy a :: operátor példája mutatta), használhatod a parent speciális nevet, ami tulajdonképpen a szülő osztály nevét jelenti, amit az extends kulcsszónál megadtál. Ennek a speciális névnek a használatával elkerülöd a szülő osztály nevének ismétlődését. Ha a megvalósítás során a leszármazási fát meg kell változtatni, csak egy helyen, az extends kulcsszónál kell átírnod a nevet.
Megjegyzés: A PHP 3-ban az objektumok elveszítik az osztály-hozzárendelésüket a szerializációs, és deszerializációs folyamat során. Az eredmény objektum típusú, de nem tartozik semelyik osztályhoz, és nincs egy metódusa sem, tehát eléggé használhatatlan (csupán egy tömb, furcsa szintakszissal).
| Figyelem |
A következő információk csak a PHP 4-es változatára érvényesek. |
A serialize() egy karaktersorozatot ad vissza, ami az átadott érték byte-sorozatban megadott megfelelője. Az unserialize() visszaalakít egy ilyen karaktersorozatot az eredeti értékké. A szerializációs folyamat során egy objektum átadásával elmenthetjük az objektum minden tulajdonságát (változóját). A függvények nem kerülnek elmentésre, csak az osztály neve.
Ahhoz, hogy az unserialize() segítségével vissza lehessen állítani egy objektumot, az objektum osztályának (típusának) már definiálva kell lennie. Ez a következőket jelenti egy példán keresztül megvilágítva: Ha az elso.php oldalon az A osztályú $a objektumot szerializálod, akkor kapsz egy olyan karaktersorozatot, amely az A osztályra hivatkozik, és tartalmazza az összes $a-ban lévő változó (tulajdonság) értékét. Ha ezt a karaktersorozatot a masodik.php oldalon objektummá szeretnéd alakítani, újra létrehozva az A osztályú $a nevű objektumot, akkor az A osztály definíciójának rendelkezésre kell állnia a masodik.php oldalon is. Ez úgy érhető el, hogy az A osztály definícióját egy külső állományban tárolod, és ezt alkalmazod mind az elso.php, mind a masodik.php oldalon.
<?php
// aosztaly.inc:
class A {
var $egy = 1;
function egyet_mutat() {
echo $this->egy;
}
}
// elso.php:
include("aosztaly.inc");
$a = new A;
$s = serialize($a);
// tároljuk az $s-t valahol, ahol masodik.php megtalálja
$fp = fopen("tarolas", "w");
fwrite($fp, $s);
fclose($fp);
// masodik.php:
// ez szükséges, hogy a deszerializáció rendben menjen
include("aosztaly.inc");
$s = implode("", @file("tarolas"));
$a = unserialize($s);
// most már használható az egyet_mutat() metódus
$a->egyet_mutat();
?> |
Ha session-öket alkalmazol, és a session_register() függvénnyel regisztálsz objektumokat, ezek az objektumok automatikusan szerializálódnak minden PHP program futása után, és deszerializálódnak minden további programban. Ez egyszerűen azt jelenti, hogy ezek az objektumok akármelyik oldalon feltűnhetnek, miután a session részévé váltak.
Erősen javasolt, hogy minden regisztrált objektum osztály definícióját betöltsd minden oldalon, még akkor is, ha éppen nem használod azokat. Ha ezt nem teszed meg, és egy objektum úgy deszerializálódik, hogy nem áll rendelkezésre az osztály definícója, el fogja veszteni az osztály hozzárendelését, és az stdClass osztály egy példánya lesz, metódusok nélkül, így használhatatlanná válik.
Ezért ha a fenti példában az $a a session részévé válik a session_register("a") meghívásával, akkor be kell töltened az aosztaly.inc külső állományt minden oldalon, nem csak az elso.php és masodik.php programokban.
A serialize() ellenőrzi, hogy van-e az osztályodnak __sleep nevű metódusa. Ha van, ez lefut a szerializáció előtt. Ez megtisztíthatja az objektumot, és végül egy tömbbel tér vissza, amely tartalmazza az adott objektum ténylegesen szerializálandó tulajdonságainak neveit.
A __sleep célja, hogy bezárjon minden adatbázis kapcsolatot, a várakozó adatokat lementse, és hasonló 'tisztító' jellegű tevékenységeket végezzen. Hasznos lehet akkor is, ha nagyon nagy objektumaid vannak, amelyeket külön szeretnél lementeni.
Ezzel szemben az unserialize() a speciális __wakeup nevű függvényt használja. Ha ez létezik, ez a függvény alkalmazható arra, hogy visszaállítsa az objektum erőforrásait.
A __wakeup célja lehet például, hogy visszaállítson egy adatbázis kapcsolatot, ami a szerializáció során elveszett, és hasonló beállítási feladatokat végezzen.
Referenciák képzése kontruktorokban problémás helyzetekhez vezethet. Ez a leírás segít a bajok elkerülésében.
<?php
class Ize {
function Ize($nev) {
// egy referencia létrehozása a globális $globalref változóban
global $globalref;
$globalref[] = &$this;
// a név beállítása a kapott értékre
$this->nevBeallitas($nev);
// és kiírás
$this->nevKiiras();
}
function nevKiiras() {
echo "<br />",$this->nev;
}
function nevBeallitas($nev) {
$this->nev = $nev;
}
}
?> |
Nézzük, hogy van-e különbség az $obj1 és az $obj2 objektum között. Az előbbi a = másoló operátorral készült, az utóbbi a =& referencia operátorral készült.
<?php
$obj1 = new Ize('konstruktorban beállított');
$obj1->nevKiiras();
$globalref[0]->nevKiiras();
/* kimenete:
konstruktorban beállított
konstruktorban beállított
konstruktorban beállított */
$obj2 =& new Ize('konstruktorban beállított');
$obj2->nevKiiras();
$globalref[1]->nevKiiras();
/* kimenete:
konstruktorban beállított
konstruktorban beállított
konstruktorban beállított */
?> |
Szemmel láthatóan nincs semmi különbség, de valójában egy nagyon fontos különbség van a két forma között: az $obj1 és $globalref[0] _NEM_ referenciák, NEM ugyanaz a két változó. Ez azért történhet így, mert a "new" alapvetően nem referenciával tér vissza, hanem egy másolatot ad.
Megjegyzés: Nincsenek teljesítménybeli problémák a másolatok visszaadásakor, mivel a PHP 4 és újabb verziók referencia számlálást alkalmaznak. Legtöbbször ellenben jobb másolatokkal dolgozni referenciák helyett, mivel a referenciák képzése eltart egy kis ideig, de a másolatok képzése gyakorlatilag nem igényel időt. Ha egyik sem egy nagy tömb, vagy objektum, és a változásokat nem szeretnéd mindegyik példányban egyszerre látni, akkor másolatok használatával jobban jársz.
<?php
// Most megváltoztatjuk a nevet. Mit vársz?
// Számíthatsz arra, hogy mind $obj1 és $globalref[0] megváltozik...
$obj1->nevBeallitas('kívülről beállítva');
// mint korábban írtuk, nem ez a helyzet
$obj1->nevKiiras();
$globalref[0]->nevKiiras();
/* kimenet:
konstruktorban beállított
kívülről beállítva */
// lássuk mi a különbség az $obj2 és $globalref[1] esetén
$obj2->nevBeallitas('kívülről beállítva');
// szerencsére ezek nem csak egyenlőek, hanem éppen ugyan az
// a két változó, így $obj2->nev és $globalref[1]->nev ugyanaz
$obj2->nevKiiras();
$globalref[1]->nevKiiras();
/* kimenete:
kívülről beállítva
kívülről beállítva */
?> |
Végül még egy utolsó példa, próbáld meg megérteni.
<?php
class A {
function A($i) {
$this->ertek = $i;
// próbáld meg kitalálni, miért nem kell itt referencia
$this->b = new B($this);
}
function refLetrehozas() {
$this->c = new B($this);
}
function ertekKiiras() {
echo "<br />",get_class($this),' osztály: ',$this->value;
}
}
class B {
function B(&$a) {
$this->a = &$a;
}
function ertekKiiras() {
echo "<br />",get_class($this),' osztály: ',$this->a->value;
}
}
// próbáld meg megérteni, hogy egy egyszerű másolás
// miért okoz nem várt eredményeket a *-al jelölt sorban
$a =& new A(10);
$a->refLetrehozas();
$a->ertekKiiras();
$a->b->ertekKiiras();
$a->c->ertekKiiras();
$a->ertek = 11;
$a->ertekKiiras();
$a->b->ertekKiiras(); // *
$a->c->ertekKiiras();
?> |
A fenti példa a következő kimenetet adja:
A osztály: 10 B osztály: 10 B osztály: 10 A osztály: 11 B osztály: 11 B osztály: 11 |
PHP 4-ben az objektumok igen egyszerű módon kerülnek összevetésre: Két objektumpéldány megegyezik, ha azonos attribútumaik, értékeik vannak, és ugyanazon osztály megtestesülései. Hasonló szabályok érvényesek két objektum azonosságának vizsgáltaára az egyezőség operátor (===) hasznélatakor.
Ha a lenti példakódot lefuttatjuk:
Példa 18-1. Példa objektum-összehasonlításra PHP 4-ben
A fenti példa a következő kimenetet adja:
|
Akkor is ezek a szabályok vannak érvényben, ha több, egységbe foglalt objektum egyben való vizsgálatáról van szó. A következő példában egy olyan hordozó osztályt hasznélunk, amely egy asszociatív tömbben tárol a fenti példából már ismert Flag típusú objektumokat.
Példa 18-2. Vegyített objektumok összehasonlítása PHP 4-ben
A fenti példa a következő kimenetet adja:
|
A PHP 5-ben új objektummodell van. A PHP objektumkezelését teljesen újraírtuk a jobb teljesítmény, és a több lehetőség figyelembevételével.
Tipp: You may also want to take a look at the R Függelék.
Minden osztálydefiníció a class kulcsszóval kezdődik, amit az osztály neve követ, ami bármi lehet, kivéve fenntartott szó a PHP-ban. Ez egy pár kapcsos zárójel ( { és } ) követ, ami tartalmazza az adattagok és metódusok definícióját. Az álváltozó, $this hozzáférhető amikor a metódust objektumon belül hívtuk meg. $this egy referencia a hívó objektumra (rendszerint az az objektum, amihez a metódus tartozik, de lehet más objektum is, ha a metódust statikusan hívtuk meg vagy másodlagos objektumból). Ezt mutatják be a következő példák:
Példa 19-1. A $this változó objektum-orientált nyelvben
A fenti példa a következő kimenetet adja:
|
Az alapértelmezett értéknek állandos (konstans) kifejezésnek kell lennie, nem (például) egy változó, osztály adattag vagy függvényhívás.
Példa 19-3. Osztály adattagok alapértelmezett értékei
|
Megjegyzés: Itt található néhány hasznos függvény osztályok és objektumok kezeléséhez. Ehhez nézdd meg a Osztály/Objektum Függvények részt.
Egy osztálypéldány létrehozásához új objektumot kell létrehozni és változóba tárolni. Az objektum mindig bekerül a változóba létrehozáskor, kivéve ha az új objektumnak van konstruktora, és ez kivételt (exception) dob vagy hibát okoz. Az osztályokat használat előtt kellene definiálni (és néhány esetben ez egy követelmény).
Amikor egy előre létrehozott objektumpéldányt tárolunk új változóba, az új változó hozzáfér ugyanahhoz a példányhoz, amit tároltunk. Így viselkedik akkor is, amikor az objetumpéldányt függvénynek adjuk át. Egy, már meglévő objektumnak a másolatát klónozással lehet elkészíteni.
Példa 19-5. Objektumok értékadása
A fenti példa a következő kimenetet adja:
|
Egy osztály örökölhet metódusokat és adattagokat már osztályoktól az extends kulcsszót használva az osztálydeklarációban. Nem lehetséges öröklös egyszerre több osztálytól, egy osztály egyszerre csak egy alap osztálytól örökölhet.
Az örökölt metódusok és adattagok felülírhatóak, hacsak nem ha azok a szülő osztályban a final kulcsszóval vannak definiálva, és ugyanazzal a névvel van definiálva a szülő osztályban. Lehetséges a hozzáférés a felülírt metódusokhoz és adattagokhoz ezeket renerenciaként használva a parent::-tal.
Példa 19-6. Egyszerű osztályöröklődés
A fenti példa a következő kimenetet adja:
|
Több objektum-orientált programot készítő fejlesztő létrehoz egy külön PHP forrásfájlt osztálydefiníciónként. Egy a legnagyobb bosszankodások közül az, hogy hosszú listát kell írni a fájlok beágyazása miatt minden program elején (egy beágyazás minden egyes osztályra).
A PHP 5-ben, ez többé nem szükséges. Te definiálhatsz egy __autoload nevű függvényt ami automatikusan meghívódik minden esetben, amikor egy olyan próbálsz meg osztályt használni, ami még nincs definiálva. Ezt a függvényt meghívva a programmotor egy utolsó esélyt ad az osztály betöltésére, mielőtt a PHP hibát eredményez.
Megjegyzés: Az __autoload függvényben dobott kivételeket nem lehet catch blokkal elkapni, és mert fatális hibát eredményez.
A PHP 5 lehetővé teszi a fejlesztők számára, hogy konstruktor metódust deklaráljanak osztályoknak. Azok az osztályok, melyeknek van konstruktor metódusuk, meghívják ezt a metódust minden egyes újonnan létrehozott objektumon, ezért ez alkalmas bármilyen kezdeti beállításhoz ami az objektum számára szükséges a használata előtt.
Megjegyzés: A szülő konstruktor nem hívódik meg, ha az utód osztály definiál egy konstruktort. A szülő konstruktor futtatásához meg kell hívni a parent::__construct() metódust az utód konstruktorban.
Példa 19-8. Új egységes konstruktorok használata
|
A visszafelé kompatibilitás érdekében ha a PHP 5 nem talál __construct() függvényt az addot osztályban, megkeresi a régi stílusú konstruktor függvényt, aminek a neve megegyezik az osztályéval. Hathatósan ez azt jelenti, hogy csak akkor van kompatibilitási probléma, ha az osztálynak van egy metódusa __construct() néven és másmilyen a szemantikája (más lenne az eredeti célja, nem az, hogy konstruktor legyen).
A PHP 5 által bevezetett destruktor hasonló a többi objektum-orientált nyelvekéhez, mint a C++. A destruktor metódus akkor hívódik meg, amint az összes referencia az egyéni objektumhoz vagy amikor az objektum nyíltan megsemmisül.
A konstruktorokhoz hasonlóan, a szülő destruktort nem hívja meg a motor közvetlenül. A szülő destruktor futtatásához nyíltan meg kell hívnod a parent::__destruct() metódust a destruktorban.
Megjegyzés: A destruktor a program leállítása során hívódik meg, tehát a fejlécek már mindig el vannak küldve.
Megjegyzés: Kivétel dobása a desturktorból fatális hibát eredményez.
Egy tulajdonság vagy metódus láthatóságát közvetlenül a deklaráció előtt kell megadni a public, protected vagy privát kulcsszavakkal. A publikusként (public) deklarált elemek bárhonnan elérhetőek. A védetteket (protected) csak az öröklő és szülő osztályokból lehet elérni (és abból az osztályból, amelyik definiálja az elemet). A privát (private) láthatóságúakat csak a definiáló osztály éri el.
Az osztály adattagokat publikusként, privátként vagy védettként kell definiálni.
Példa 19-10. Adattag deklaráció
|
Megjegyzés: A PHP 4 változó deklarálási metódusa a var kulcsszóval még támogatott kompatibilitási okok miatt (a public kulcsszó szinonímájaként). Az 5.1.3 verzió előtti PHP 5 motorok E_STRICT típusú hibát generáltak.
Az osztály metódosuait publikusként, privátként vagy védettként kell defiiálni. A láthatóság nélküli metódusok pulikusak lesznek.
Példa 19-11. Method Declaration
|
The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden members or methods of a class.
When referencing these items from outside the class definition, use the name of the class.
Paamayim Nekudotayim would, at first, seem like a strange choice for naming a double-colon. However, while writing the Zend Engine 0.5 (which powers PHP 3), that's what the Zend team decided to call it. It actually does mean double-colon - in Hebrew!
Two special keywords self and parent are used to access members or methods from inside the class definition.
When an extending class overrides the parents definition of a method, PHP will not call the parent's method. It's up to the extended class on whether or not the parent's method is called. This also applies to Constructors and Destructors, Overloading, and Magic method definitions.
Példa 19-14. Calling a parent's method
|
A statikus (static) osztály adattagok vagy metódusok elérhetőek bármilyen osztálypéldány segítsége nélkül. Egy statikusként deklarált adattag nem érhető el egy példányosított objektumból (bár egy statikus metódust el lehet érni).
A statikus deklarációnak a láthatóság deklarációja után kell lenni. A PHP 4-gyel való kompatibilitás miatt, ha nincs láthatóság deklaráció, az adattag vagy metódus publikus láthatósággal fog rendelkezni.
Mivel a statikus metódusok meghívhatóak osztálypéldány nélkül, a $this ál-változó nem érhető el a statikus metóduson belül.
Valójában a statikus metódushívások a fordítás idejében meghatározódnak. Amikor egyértelmű osztálynevet használsz egy, már teljesen azonosított metódus használatánál, nincs semmilyen öröklődési szabály. Ha a hívást self-fel végzed, a self-et a jelenlegi osztályként fordítja le a motor, ez az az oszály, amelyikhez a kód tartozik. Itt sincs semmilyen öröklődési szabály.
Statikus tulajdonságok nem érhetőek el az objektumon keresztül a -> operátort használva.
Nem statikus metódusok statutikus meghívása esetén a motor E_STRICT szintű hibát generál.
Példa 19-15. Statikus adattag példa
|
Lehetséges konstans értékek definiálása amelyeknek értéke állandó, és megváltozhatatlan. A konstansok használata annyiban tér el a rendes változóktól, hogy nem kell a $ jelet használni deklarálásukhoz vagy elérésükhöz. A statikus adattagokhoz hasonlóan, a konstant értékekhez sem lehet közvetlenül hozzáférni az objektumpéldányon keresztül ($object::constant használata).
Az értéknek konstant kifejezésnek kell lennie, nem (például) egy változó, egy osztály adattag, egy matematikai művelet eredménye vagy függvényhívás.
A PHP 5 lehetővé teszi az elvont osztályok és metódusok használatát. Nem lehet elvont osztálynak objektumtumpéldányát készíteni. Minden osztálynak elvontnak kell lennie, ami legalább egy elvont metódust tartalmaz. Az elvont metódusokak egyszerű metódusként kell deklarálni, de nem tartalmazhatnak belső kódot.
Amikor egy osztály elvont osztálytól örököl, minden elvont metódust deklarálni kell az osztályban; pótlólag ezeknek a metódusoknak ugyanolyan (vagy gyengébb) láthatósággal (visibillity) kell rendelkeznie. Például, ha egy elvont metódus "protected", a függvénynek vagy "protected"-nek, vagy "public"-nak kell lennie.
Példa 19-18. Elvont osztály példa
A fenti példa a következő kimenetet adja:
|
Öreg kódnak, melynek nincs felhasználó által definált 'abstarct' nevű osztálya vagy függvénye módosítások nélkül futnia kell.
Az objektum interfészek lehetővé teszik, hogy létrehozz egy kódot mely megszabja, milyen metódusokat kötelező implementálni anélkül, hogy definiáljuk ezeknek a metódusoknak a kezelését.
Az interfészeket az interface kulcsszóval lehet definiálni, ugyanúgy mint az általános osztályokat, de a metódusok tartalma nélkül.
Minden interfészben definiált metódusnak publikusnak kell lennie, ez a természetes egy interfészben.
Egy interfész megvalósításához az implements kezelőt kell használni. Minden interfészben szereplő metódust meg kell valósítani az osztályba, különben a program fatális hibát eredményez. Az osztályok több, mint egy interfészt is megvalósíthatnak, ha ezeket vesszővel választjuk el.
Megjegyzés: Egy osztály nem valósíthat meg két interfészt amelyek azonos függvényneveket tárolnak, ugyanis ez kétértelműséget okozhat.
Példa 19-19. Interface example
|
Lásd még az instanceof operátort.
Both method calls and member accesses can be overloaded via the __call, __get and __set methods. These methods will only be triggered when your object or inherited object doesn't contain the member or method you're trying to access. All overloading methods must not be defined as static. In PHP 5.0.x, all overloading methods must be defined as public.
Since PHP 5.1.0 it is also possible to overload the isset() and unset() functions via the __isset and __unset methods respectively.
Class members can be overloaded to run custom code defined in your class by defining these specially named methods. The $name parameter used is the name of the variable that should be set or retrieved. The __set() method's $value parameter specifies the value that the object should set the $name.
Példa 19-20. overloading with __get, __set, __isset and __unset example
A fenti példa a következő kimenetet adja:
|
Class methods can be overloaded to run custom code defined in your class by defining this specially named method. The $name parameter used is the name as the function name that was requested to be used. The arguments that were passed in the function will be defined as an array in the $arguments parameter. The value returned from the __call() method will be returned to the caller of the method.
Példa 19-21. overloading with __call example
A fenti példa a következő kimenetet adja:
|
PHP 5 provides a way for objects to be defined so it is possible to iterate through a list of items, with, for example a foreach statement. By default, all visible properties will be used for the iteration.
Példa 19-22. Simple Object Iteration
A fenti példa a következő kimenetet adja:
|
As the output shows, the foreach iterated through all visible variables that can be accessed. To take it a step further you can implement one of PHP 5's internal interface named Iterator. This allows the object to decide what and how the object will be iterated.
Példa 19-23. Object Iteration implementing Iterator
A fenti példa a következő kimenetet adja:
|
You can also define your class so that it doesn't have to define all the Iterator functions by simply implementing the PHP 5 IteratorAggregate interface.
Példa 19-24. Object Iteration implementing IteratorAggregate
A fenti példa a következő kimenetet adja:
|
Megjegyzés: For more examples of iterators, see the SPL Extension.
Patterns are ways to describe best practices and good designs. They show a flexible solution to common programming problems.
The Factory pattern allows for the instantiation of objects at runtime. It is called a Factory Pattern since it is responsible for "manufacturing" an object. A Parameterized Factory receives the name of the class to instantiate as argument.
Példa 19-25. Parameterized Factory Method
Defining this method in a class allows drivers to be loaded on the fly. If the Example class was a database abstraction class, loading a MySQL and SQLite driver could be done as follows:
|
The Singleton pattern applies to situations in which there needs to be a single instance of a class. The most common example of this is a database connection. Implementing this pattern allows a programmer to make this single instance easily accessible by many other objects.
Példa 19-26. Singleton Function
This allows a single instance of the Example class to be retrieved.
|
The function names __construct, __destruct (see Constructors and Destructors), __call, __get, __set, __isset, __unset (see Overloading), __sleep, __wakeup, __toString, __set_state, __clone and __autoload are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.
| Figyelem |
PHP reserves all function names starting with __ as magical. It is recommended that you do not use function names with __ in PHP unless you want some documented magic functionality. |
serialize() checks if your class has a function with the magic name __sleep. If so, that function is executed prior to any serialization. It can clean up the object and is supposed to return an array with the names of all variables of that object that should be serialized.
The intended use of __sleep is to close any database connections that the object may have, commit pending data or perform similar cleanup tasks. Also, the function is useful if you have very large objects which do not need to be saved completely.
Conversely, unserialize() checks for the presence of a function with the magic name __wakeup. If present, this function can reconstruct any resources that the object may have.
The intended use of __wakeup is to reestablish any database connections that may have been lost during serialization and perform other reinitialization tasks.
Példa 19-27. Sleep and wakeup
|
The __toString method allows a class to decide how it will react when it is converted to a string.
It is worth noting that before PHP 5.2.0 the __toString method was only called when it was directly combined with echo() or print().
This static method is called for classes exported by var_export() since PHP 5.1.0.
The only parameter of this method is an array containing exported properties in the form array('property' => value, ...).
A PHP 5 bevezeti a final kulcsszót, ami megakadályozza ezzel a kulcsszóval definiált metódusok felülírását az öröklő osztályokban. Ha az oszály a final kulcsszóval van definiálva, nem lehet már egy osztálynak se szülő osztálya.
Példa 19-29. Zárt metódus példa
|
Példa 19-30. Zárt osztály példa
|
Egy objektum másolatának az elkészítéséhez az összes tulajdonság teljes másolásával nem mindig eredményezi a várt viselkedést. Egy jó példa, amikor a konstruktorok másolata szükséges, ha neked van egy objektumod ami GTK ablakot képvisel, és te létre akarsz hozni egy új ablakot ugyanazokkal a tulajdonságokkal hogy az új objektum tárolja a forrását az új ablaknak. Másik példa ha a te objektumod referenciát tárol egy másik objektumhoz, és ha te létre akarsz hozni egy másolat objektumot, amiben ennek a másik objektumnak is külön másolata lesz.
Egy objektum másolatát a clone kulcsszó használatával lehet létrehozni (ami meghívja az objektum __clone() metódusát, ha lehetséges). Az objektum __clone() metódusa nem hívható meg közvetlenül.
Amikor egy objektum klónozott, a PHP 5 létrehoz egy felületes másolatot az objektum tulajdonságairól. Valamennyi tulajdonság, ami referencia más változókhoz, referencia fog maradni. Ha a _clone() metódus definiált, az újonnan elkészített objektum __clone() metódusa fog meghívódni, hogy engedélyezze bármely szükség esetén a tulajdonságok cseréjét.
Példa 19-31. Objektum klónozása
A fenti példa a következő kimenetet adja:
|
In PHP 5, object comparison is more complicated than in PHP 4 and more in accordance to what one will expect from an Object Oriented Language (not that PHP 5 is such a language).
When using the comparison operator (==), object variables are compared in a simple manner, namely: Two object instances are equal if they have the same attributes and values, and are instances of the same class.
On the other hand, when using the identity operator (===), object variables are identical if and only if they refer to the same instance of the same class.
An example will clarify these rules.
Példa 19-32. Example of object comparison in PHP 5
A fenti példa a következő kimenetet adja:
|
PHP 5 comes with a complete reflection API that adds the ability to reverse-engineer classes, interfaces, functions and methods as well as extensions. Additionally, the reflection API also offers ways of retrieving doc comments for functions, classes and methods.
The reflection API is an object-oriented extension to the Zend Engine, consisting of the following classes:
<?php
class Reflection { }
interface Reflector { }
class ReflectionException extends Exception { }
class ReflectionFunction implements Reflector { }
class ReflectionParameter implements Reflector { }
class ReflectionMethod extends ReflectionFunction { }
class ReflectionClass implements Reflector { }
class ReflectionObject extends ReflectionClass { }
class ReflectionProperty implements Reflector { }
class ReflectionExtension implements Reflector { }
?> |
Megjegyzés: For details on these classes, have a look at the next chapters.
If we were to execute the code in the example below:
Példa 19-33. Basic usage of the reflection API
A fenti példa a következő kimenetet adja:
|
ReflectionException extends the standard Exception and is thrown by Reflection API. No specific methods or properties are introduced.
The ReflectionFunction class lets you reverse-engineer functions.
<?php
class ReflectionFunction implements Reflector
{
final private __clone()
public object __construct(string name)
public string __toString()
public static string export(string name, bool return)
public string getName()
public bool isInternal()
public bool isUserDefined()
public string getFileName()
public int getStartLine()
public int getEndLine()
public string getDocComment()
public array getStaticVariables()
public mixed invoke(mixed args)
public mixed invokeArgs(array args)
public bool returnsReference()
public ReflectionParameter[] getParameters()
public int getNumberOfParameters()
public int getNumberOfRequiredParameters()
}
?> |
Megjegyzés: getNumberOfParameters() and getNumberOfRequiredParameters() were added in PHP 5.0.3, while invokeArgs() was added in PHP 5.1.0.
To introspect a function, you will first have to create an instance of the ReflectionFunction class. You can then call any of the above methods on this instance.
Példa 19-34. Using the ReflectionFunction class
|
Megjegyzés: The method invoke() accepts a variable number of arguments which are passed to the function just as in call_user_func().
The ReflectionParameter class retrieves information about a function's or method's parameters.
<?php
class ReflectionParameter implements Reflector
{
final private __clone()
public object __construct(string name)
public string __toString()
public static string export(mixed function, mixed parameter, bool return)
public string getName()
public bool isPassedByReference()
public ReflectionFunction getDeclaringFunction()
public ReflectionClass getDeclaringClass()
public ReflectionClass getClass()
public bool isArray()
public bool allowsNull()
public bool isPassedByReference()
public bool getPosition()
public bool isOptional()
public bool isDefaultValueAvailable()
public mixed getDefaultValue()
}
?> |
Megjegyzés: getDefaultValue(), isDefaultValueAvailable() and isOptional() were added in PHP 5.0.3, while isArray() was added in PHP 5.1.0. getDeclaringFunction() and getPosition() were added in PHP 5.1.3.
To introspect function parameters, you will first have to create an instance of the ReflectionFunction or ReflectionMethod classes and then use their getParameters() method to retrieve an array of parameters.
Példa 19-35. Using the ReflectionParameter class
|
The ReflectionClass class lets you reverse-engineer classes.
<?php
class ReflectionClass implements Reflector
{
final private __clone()
public object __construct(string name)
public string __toString()
public static string export(mixed class, bool return)
public string getName()
public bool isInternal()
public bool isUserDefined()
public bool isInstantiable()
public bool hasConstant(string name)
public bool hasMethod(string name)
public bool hasProperty(string name)
public string getFileName()
public int getStartLine()
public int getEndLine()
public string getDocComment()
public ReflectionMethod getConstructor()
public ReflectionMethod getMethod(string name)
public ReflectionMethod[] getMethods()
public ReflectionProperty getProperty(string name)
public ReflectionProperty[] getProperties()
public array getConstants()
public mixed getConstant(string name)
public ReflectionClass[] getInterfaces()
public bool isInterface()
public bool isAbstract()
public bool isFinal()
public int getModifiers()
public bool isInstance(stdclass object)
public stdclass newInstance(mixed args)
public stdclass newInstanceArgs(array args)
public ReflectionClass getParentClass()
public bool isSubclassOf(ReflectionClass class)
public array getStaticProperties()
public mixed getStaticPropertyValue(string name [, mixed default])
public void setStaticPropertyValue(string name, mixed value)
public array getDefaultProperties()
public bool isIterateable()
public bool implementsInterface(string name)
public ReflectionExtension getExtension()
public string getExtensionName()
}
?> |
Megjegyzés: hasConstant(), hasMethod(), hasProperty(), getStaticPropertyValue() and setStaticPropertyValue() were added in PHP 5.1.0, while newInstanceArgs() was added in PHP 5.1.3.
To introspect a class, you will first have to create an instance of the ReflectionClass class. You can then call any of the above methods on this instance.
Példa 19-36. Using the ReflectionClass class
|
Megjegyzés: The method newInstance() accepts a variable number of arguments which are passed to the function just as in call_user_func().
Megjegyzés: $class = new ReflectionClass('Foo'); $class->isInstance($arg) is equivalent to $arg instanceof Foo or is_a($arg, 'Foo').
The ReflectionMethod class lets you reverse-engineer class methods.
<?php
class ReflectionMethod extends ReflectionFunction
{
public __construct(mixed class, string name)
public string __toString()
public static string export(mixed class, string name, bool return)
public mixed invoke(stdclass object, mixed args)
public mixed invokeArgs(stdclass object, array args)
public bool isFinal()
public bool isAbstract()
public bool isPublic()
public bool isPrivate()
public bool isProtected()
public bool isStatic()
public bool isConstructor()
public bool isDestructor()
public int getModifiers()
public ReflectionClass getDeclaringClass()
// Inherited from ReflectionFunction
final private __clone()
public string getName()
public bool isInternal()
public bool isUserDefined()
public string getFileName()
public int getStartLine()
public int getEndLine()
public string getDocComment()
public array getStaticVariables()
public bool returnsReference()
public ReflectionParameter[] getParameters()
public int getNumberOfParameters()
public int getNumberOfRequiredParameters()
}
?> |
To introspect a method, you will first have to create an instance of the ReflectionMethod class. You can then call any of the above methods on this instance.
Példa 19-37. Using the ReflectionMethod class
|
Megjegyzés: Trying to invoke private, protected or abstract methods will result in an exception being thrown from the invoke() method.
Megjegyzés: For static methods as seen above, you should pass NULL as the first argument to invoke(). For non-static methods, pass an instance of the class.
The ReflectionProperty class lets you reverse-engineer class properties.
<?php
class ReflectionProperty implements Reflector
{
final private __clone()
public __construct(mixed class, string name)
public string __toString()
public static string export(mixed class, string name, bool return)
public string getName()
public bool isPublic()
public bool isPrivate()
public bool isProtected()
public bool isStatic()
public bool isDefault()
public int getModifiers()
public mixed getValue(stdclass object)
public void setValue(stdclass object, mixed value)
public ReflectionClass getDeclaringClass()
public string getDocComment()
}
?> |
Megjegyzés: getDocComment() was added in PHP 5.1.0.
To introspect a property, you will first have to create an instance of the ReflectionProperty class. You can then call any of the above methods on this instance.
Példa 19-38. Using the ReflectionProperty class
|
Megjegyzés: Trying to get or set private or protected class property's values will result in an exception being thrown.
The ReflectionExtension class lets you reverse-engineer extensions. You can retrieve all loaded extensions at runtime using the get_loaded_extensions().
<?php
class ReflectionExtension implements Reflector {
final private __clone()
public __construct(string name)
public string __toString()
public static string export(string name, bool return)
public string getName()
public string getVersion()
public ReflectionFunction[] getFunctions()
public array getConstants()
public array getINIEntries()
public ReflectionClass[] getClasses()
public array getClassNames()
}
?> |
To introspect an extension, you will first have to create an instance of the ReflectionExtension class. You can then call any of the above methods on this instance.
Példa 19-39. Using the ReflectionExtension class
|
In case you want to create specialized versions of the built-in classes (say, for creating colorized HTML when being exported, having easy-access member variables instead of methods or having utility methods), you may go ahead and extend them.
Példa 19-40. Extending the built-in classes
|
Megjegyzés: Caution: If you're overwriting the constructor, remember to call the parent's constructor _before_ any code you insert. Failing to do so will result in the following: Fatal error: Internal error: Failed to retrieve the reflection object
PHP 5 introduces Type Hinting. Functions are now able to force parameters to be objects (by specifying the name of the class in the function prototype) or arrays (since PHP 5.1).
Példa 19-41. Type Hinting examples
Failing to satisfy the type hint results in a fatal error.
Type hinting also works with functions:
|
Type Hints can only be of the object and array (since PHP 5.1) type. Traditional type hinting with int and string isn't supported.
A PHP 5 kivétel modellje hasonló más programozási nyelvekéhez. Egy kivételt dobhatunk (throw) és elkaphatunk (catch) a PHP-val. A kódot try blokkba kell tenni, hogy megkönnyítsük lehetséges kivétélek kezelését. Minden try blokknak rendelkezni kell legalább egy megfelelő catch blokkal. Többszörös catch blokkokat is használhatunk, így különböző osztályú kivételeket kaphatunk el. A program (ha nincs kivétel a try blokkban, vagy ha a kivétel nem illeszkedik egy catch blokkra sem) az utolsó catch blokk után folytatódik. Kivételek dobhatóak (throw) (vagy újradobhatóak) a catch blokkban.
Ha kivételt dobtunk, a blokkban a következő kód már nem fut le, és a PHP megkeresi az első catch blokkot, amire illeszkedik a kivétel. Ha a kivételt nem sikerült elkapni, a PHP fatális hibát (Fatal Error) ad ki "Uncaught Exception ..." szöveggel, hacsak nincs a set_exception_handler() beállítva.
A felhaszánló is hozhat létre saját kivételeket, amiket a beépített Exception osztályra kell kiterjeszteni. A tagok és tuladonságok lejjebb megmutatják, mihez lehet hozzáférni az utód osztályban, amit a beépített Exception osztálytól örököl.
Példa 20-2. A beépített Exception osztály
|
Ha az osztály utódja a beépített Exception osztálynak, és újradefinálja a konstruktort, erősen ajánlott, hogy meghívja a parent::__construct() metódust hogy biztosítsa, minden hozzáférhető adat helyesen legyen tárolva. A __toString() metódus úrjaírható, hogy tetszőleges legyen az objektum által prezentált karakterlánc.
Példa 20-3. Exception osztály kiterjesztése
|
A referenciák lehetőséget adnak PHP-ben azonos változó tartalom elérésére különböző nevek alatt. Ezek szimbólumtábla bejegyzések, nem olyanok, mint a C nyelv mutatói. PHP-ben a változók neve és tartalma két különböző dolog, tehát ugyanaz a tartalom kaphat különböző neveket. A legjobb hasonlat talán a UNIX állománynevek és állományok rendszere. A változóneveket könyvtár bejegyzésekként foghatod fel, a változók tartalmát állományokként. A referenciák olyanok, mint UNIXban a hardlinkek.
A PHP referenciák lehetőséget adnak arra, hogy egy értékhez két nevet lehessen rendelni. Ez azt jelenti, hogy a következő programban:
Az $a és $b nevek ugyanarra az értékre hivatkoznak.Megjegyzés: Az $a és a $b nevek teljesen egyenrangúak. Nem arról van szó, hogy az $a a $b-re mutat, vagy fordítva, hanem arról, hogy az $a és a $b név ugyanannak az értéknek két elnevezése.
Megjegyzés: Ha egy referenciákat tartalmazó tömböt másolunk, a referenciák másolódnak, nem az értékek. Ugyanez igaz az érték szerinti paraméterátadásnál is.
Ugyanez a forma használható az olyan függvényeknél, amelyek referenciát adnak vissza, vagy a new operátor használatakor (a PHP 4.0.4 és későbbi verziókban):
Megjegyzés: Ha nem használod az & -t, akkor az osztálypéldány másoláta adódik át. A $this objektumon belüli használatával ugyanazon az objektumpéldányon dolgozol. Ha az értékadás során az & -t elhagyod, akkor az objektumról másolat készül és a $this már ezen a másolaton fog dolgozni. Van, amikor ez nem kívánatos, mivel általában egy példányon szeretnénk dolgozni a jobb memóriahasználat és teljesítmény érdekében.
Az @ operátort nem lehet együtt használni a &new utasítással, amivel el lehetne nyomni a konstruktorban fellépő hibákról történő jelzéseket. Ez a jelenlegi Zend motor egyik korlátja, és ezért fordítási hibát (parse error-t) fog jelezni, ha ilyet talál.
| Figyelem | ||
Ha egy függvényen belül egy global jelzővel ellátott változóhoz referenciát rendelsz hozzá, az a referencia csak a függvény belsejében lesz látható. Ennek elkerülésére használd a $GLOBALS tömböt.
|
Megjegyzés: Ha egy referenciákkal rendelkező változót adsz meg a foreach utasításban, a referenciák is fognak módosulni.
| Figyelem | |
Az összetettebb tömbök inkább átmásolódnak mint hogy referenciák készüljenek róluk. Ennek következtében a következő példa nem úgy fog működni ahogy azt elárnánk. |
A a referenciákat paraméterátadáskor is lehet használni. Ebben az esetben a meghívott függvény egy lokális változója és a hívó környezet egy változója ugyanazt az értéket fogja képviselni. Például:
Ez a kód az $a változó értékét 6-ra állítja. Ez azért történik meg, mivel az ize függvényben a $valtozo egy referencia a $a változó értékére. A részletes leírást a referenciakénti paraméterátadás c. fejezetben olvashatod.A referenciák harmadik felhasználási módja a refencia visszatérési-érték.
Mint korábban írtuk, a referenciák nem mutatók. A következő konstrukció ezért nem a vártnak megfelelően viselkedik:
Az ize függvényben a $valtozo változó a $valami értékéhez lesz kötve, de utána ezt megváltoztatjuk a $GLOBALS["valami"] értékére. Nincs lehetőség a referenciák segítségével a $valami más értékhez kötésére a hívó környezetben, mivel a $valami nem áll rendelkezésre az ize függvényben. Ott a $valtozo reprezentálja az értékét, amely csak változó tartalommal bír és nem név-érték kötéssel a hívó szimbólumtáblájában. A függvény által kijelölt változó hivatkozásához használhatod a referencia visszatérítést.
A függvényeknek változókat referenciaként is át lehet adni, így a függvény tudja módosítani a hívó környezetben definiált értéket. Ez a következőképpen oldható meg:
Figyeld meg, hogy nincs referencia jelzés a függvényhíváskor, csak a függvény definíciójában. Ez önmagában elég a megfelelő működéshez. A PHP újabb verzióiban, egy figyelmeztetést fogsz kapni, hogy a referencia szerinti átadás hívásidőben (Call-time pass-by-reference) elavult, ha & jelet használsz ilyen esetben: foo(&$a);.A következők szerepelhetnek referenciakénti paraméterátadásban:
Változó, például ize($a)
New utasítás, például ize(new osztaly())
Egy függvény által visszaadott referencia, például:
Lásd még a refencia visszatérési-érték leírását.Minden más kifejezést kerülni kell referencia szerinti paraméterátadáskor, mivel az eredmény határozatlan lesz. A következő példákban a referencia szerinti paraméterátadás hibának minősül:
Ezek a meghatározások a PHP 4.0.4 és későbbi verzióira érvényesek.A refencia visszatérési-érték pl. olyan változók megtalálásakor lehet hasznos, amelyekről referenciát kell készíteni. Ne használj referencia szerinti visszaadást teljesítménynövelési célból, a motor elég okos ahhoz, hogy magától optimizálja a kódot, csak akkor adj vissza referenciát, ha ésszerű technikai okod van rá. Ha referenciát kell visszaadni visszatérési értékként, akkor használd az alábbi formát:
<?php
function &valtozo_kereses($param)
{
/* ...kód... */
return $megtalalt_valtozo;
}
$ize =& valtozo_kereses($valami);
$ize->x = 2;
?> |
Megjegyzés: A paraméter átadással ellentétben, itt a & jelet mindkét helyen meg kell adnod a referenciavisszaadás jelöléséhez. Így nem egy másolatot kapsz, és az $ize változóra nézve referencia hozzárendelés történik, nem pedig érték hozzárendelés (értékmásolás).
Megjegyzés: Ha ilyen szintaxissal akarsz referenciát visszaadni függvényből: return ($found_var);, akkor ez nem fog működni, mivel ez egy kifejezés eredményét adja vissza, és nem egy változót referencia szerint. Csak változót adhatsz vissza referencia szerint, semmi mást.
Amikor megszüntetsz egy referenciát, csak megszakítod a változónév és az érték közötti kapcsolatot. Ez nem azt jelenti, hogy a váltózó értékét törlöd. Például:
nem fogja megszüntetni a $b nevet, csak az $a nevet, így az érték a $b néven továbbra is elérhető.Ismét érdemes a Unix unlink parancsával és az állományrendszerrel való hasonlatosságra gondolni.
Sok konstrukció a PHP-ben referenciák segítségével valósul meg, azért minden fentebb tárgyalt kérdés ezekre az elemekre is igaz. Néhány olyan konstrukciót, mint a referencia átadást vagy visszatérést már kifejtettünk, más referenciákat használó konstrukciók:
Amikor egy változót a global $valtozo formával globálisként használsz, tulajdonképpen egy referenciát képzel a megfelelő globális változóra,azaz a következő kódnak megfelelő történik:
Ez például azt is jelenti, hogy a $valtozo törlése nem fogja törölni a globális változót.
A PHP egy igen hatékony nyelv és feldolgozó program, akár kiszolgálómodulként, akár egy különálló CGI futtatható állományként működik. Képes elérni fájlokat, futtatni parancsokat és hálózati kapcsolatokat nyitni a szerveren. Ezek a tulajdonságok alapesetben veszélyessé is tehetik más, a webszerveren futó alkalmazások számára. A PHP-t azonban úgy fejlesztették, hogy biztonságosabb legyen CGI programok írására, mint a Perl vagy C nyelvek. A PHP a fordítási és futásidejű beállítások helyes megválasztásával, és megfelelő programírási módszerek betartásával a szabadság és biztonság kívánt kombinációját biztosítja a fejlesztők számára.
Mivel sokféleképpen és sok mindenre lehet használni a PHP-t, számos konfigurációs lehetőség van a működésének szabályozására. A lehetőségek nagy száma garantálja, hogy a PHP-t sokféleképpen fel lehet használni, de egyben azt is jelenti, hogy ezek és a webkiszolgáló beállításainak kombinációi kritikus helyzeteket teremthetnek.
A beállítások sokszínűsége egyenlő mértékű a kódok sokszínűségével. A PHP használható teljes szerver-alkalmazások készítésére, egy shell felhasználó minden lehetőségével, vagy használható egyszerű 'server side include'-oknál, kis kockázattal egy szigorúan ellenőrzött rendszerben. Az, hogy hogyan kell kialakítani egy környezetet, milyen biztonságosan, nagyban a PHP fejlesztőn múlik.
Ez a fejezet néhány biztonsági tanácsot tárgyal, a különböző beállítási lehetőségeket és azokat a helyzeteket tárja fel, amelyekben ezeket biztonsággal lehet használni. Utána néhány kódolási szempontot is érint a különböző szintű védelem szempontjából.
A teljesen biztonságos rendszer kialakítani tulajdonképpen lehetlen, ezért a védelmi szakterületen alkalmazott megközelítés a kockázat és a használhatóság közti egyensúly megteremtésére törekszik. Ha minden a felhasználó által küldött adat két biometrikus érvényesítést (pl. retina- és ujjlenyomatvizsgálatot) igényel, akkor igen magas szintű a rendszer "felelősségre vonhatósága" (accountability). Ez azonban azt jelentené, hogy félórába telne kitölteni egy meglehetősen összetett űrlapot, ami arra ösztökélné a felhasználókat, hogy valahogy megkerüljék ezt a védelmet.
A legjobb védelem gyakran a kevésbé alkalmatlankodó és nem annyira feltűnő fajta, amely megfelel a követelményeknek anélkül, hogy megakadályozná a felhasználókat a munkájuk elvégzésében vagy túlterhelné a program íróit annak túlzott mérvű bonyolultsága. Valójában néhány biztonsági támadás pusztán a kiaknázása az olyasfajta túlságosan is kiépített védelemnek, amely hajlamos elerodálódni az idővel.
Egy mondatot érdemes megjegyezni: A rendszer csakis annyira jól védett, amennyire a leggyengébb láncszeme. Ha minden tranzakcióról feljegyzés készül idő, hely és tranzakciótípus alapján is, de a felhasználót csak egy egyszerű süti (cookie) alapján azonosítja a rendszer, akkor a felhasználók és a naplózott tranzakciók közti összefüggések érvényessége, megbízhatósága igen gyenge.
Tesztelés során figyelembe kell venni, hogy képtelenség minden lehetőséget kipróbálni már a legegyszerűbb oldalak esetén is. A programozó által várt adatok teljesen különbözőek azoktól és minden összefüggést nélkülöznek azokkal, amelyeket egy zsémbelődő alkalmazott képes elküldeni, vagy amelyeket egy szoftverkalóz (cracker) több havi munkájával állít össze, vagy amit egy házimacska a billenytyűzeten végiggyalogolva bevisz. Ezért a legjobb a programot logikai nézőpontból megközelíteni, hogy sikerüljön észrevenni, hol jöhetnek elő nem várt adatok és azok a továbbiakban hogyan módosulhatnak, tűnhetnek el vagy erősödhetnek fel a hatásuk.
Az Internet tele van olyan emberekkel, akik azzal akarnak maguknak nevet szerezni, hogy feltörik az oldalaidat, tönkreteszik a programjaidat, nem helyénvaló tartalommal töltik fel azokat, mellesleg egy - két izgalmas(?) napot szerezve ezzel Neked. Nem számít, hogy kis vagy nagy webhelyről van szó, elég indok a támadásra, hogy az rá van kapcsolva a hálóra, van egy szerver, amelyhez csatlakozni lehet. Sok kódtörő program nem foglalkozik a méretekkel, egyszerűen csak nagy mennyiségű IP blokkokra vadászik áldozatokat keresve ezzel magának. Próbálj meg nem egy lenni közülük!
A PHP CGI futtatható állományként való használata egy telepítési lehetőség azok számára, akik valami oknál fogva nem szeretnék a PHP-t modulként a szerverbe integrálni (pl. Apache), vagy a PHP-t más CGI wrapper-ekkel szeretnék használni biztonságos chroot és setuid környezet kialakítása érdekében. Ez a forma magával vonja azt, hogy a PHP a szerver cgi-bin könyvtárába legyen telepítve. A CERT advisory CA-96.11 azt tanácsolja, hogy ne tegyél feldolgozó (interpreter) programot a cgi-bin könyvtárba. Bár a PHP használható mint egy egyedülálló feldolgozó program, a PHP-t úgy tervezték, hogy az ilyen telepítésekből adódó támadásokat kivédje:
Rendszerfájlok elérése: http://domain.nev/cgi-bin/php?/etc/passwd
Az URL lekérési információja (query information), ami a kérdőjel (?) után található, parancssori paraméterként kerül átadásra a feldolgozónak. Általában a feldolgozók megnyitják, és lefuttatják az első paraméterként adott fájlt.
Ha a PHP CGI futtatható állományként hívódik meg, nem veszi figyelembe a parancssori paramétereket.
Bármilyen web dokumentum elérése a szerveren: http://domain.nev/cgi-bin/php/titkos/doc.html
Az elérési út információ (path information) az URL része, a futtatható fájl neve után lévő /titkos/doc.html a CGI program által megnyitásra és futtatásra kerülő fájl elérésének meghatározására használatos. Tipikusan néhány webkiszolgáló beállítási lehetőség (Apache-ban: Action) használatos a kérések átirányítására a dokumentumhoz, mint a http://domain.nev/titkos/szkript.php a PHP értelmező számára. Ezzel a beállítással a szerver először ellenőrzi az elérési engedélyeket a /titkos könyvtárra, és ezután állítja elő az átirányító kérést a http://domain.nev/cgi-bin/php/titkos/szkript.php oldalra, amit így már a PHP feldolgoz. Azonban ha eredetileg is ebben a formában volt megadva a kérés, nem történik elérési ellenőrzés a /titkos/szkript.php fájlra, csak a /cgi-bin/php fájlra. Ilyen módon bárki, aki elérheti a /cgi-bin/php címet, egyben tetszőleges védett dokumentumot is elérhet.
A PHP esetében az --enable-force-cgi-redirect fordítási paraméter, a doc_root és user_dir konfigurációs lehetőségek használhatóak ennek kivédésére, ha a szerver dokumentumainak könyvtárfájában van olyan könyvtár, ami elérési korlátozásokkal bír. Nézd meg az alábbi lehetőségeket a különböző kombinációkhoz!
Ha a szerveren nincs olyan tartalom, ami jelszó vagy IP alapú védelemmel van ellátva, nincs szükség ezekre a konfigurációs beállításokra. Ha a kiszolgáló nem engedélyezi az átirányításokat, illetve ha nincs módja biztonságos átirányítással küldeni a kérést a PHP számára, megadhatod az --enable-force-cgi-redirect opciót a "configure" szkript számára. Meg kell győződnöd arról, hogy a PHP szkriptjeid nem függnek egy speciális szkript-hívási formától sem, mint a http://domain.nev/cgi-bin/php/dir/szkript.php vagy a http://domain.nev/dir/szkript.php.
Az átirányítás beállítása Apache alatt az AddHandler és Action direktívákkal történik (lásd lentebb).
Ez a fordítási paraméter megakadályozza, hogy bárki meghívja a PHP-t egy http://domain.nev/cgi-bin/php/titkos/szkript.php. URL-el. Ehelyett a PHP csak akkor fog elfogadni egy ilyen kérést ha egy szerver átirányításban kapta.
Apache esetében tipikusan a következő direktívákkal történik a beállítás:
Action php-script /cgi-bin/php AddHandler php-script .php |
Ez a lehetőség csak az Apache web szerverrel tesztelt és azon múlik, hogy az Apache beállítja a nem standard REDIRECT_STATUS CGI környezeti változót ha átirányított kérésről van szó. Ha a webkiszolgálód semmilyen módon nem közli, hogy ez egy direkt vagy átirányított kérés volt-e, nem használhatod ezt az opciót, így valamelyik másik módot kell használnod.
Aktív tartalom elhelyezése a normál dokumentumok között, (pl. szkriptek és futtatható állományok) veszélyes gyakorlat lehet. Ha például valamilyen beállítási hiba miatt a szkriptek ahelyett, hogy lefutnának hagyományos HTML dokumentumokként jelennek meg, mindenki számára tisztán láthatóvá válnak kódolási technikáid és titkos információk, mint például adatbázis jelszavaid. Ezért néhány rendszeradminisztrátor inkább egy külön könyvtárat jelöl ki, ami csak a PHP CGI által elérhető, és így mindig feldolgozásra kerül és nem jelenik meg a szkript kódja.
Ha a fent leírt átirányítás azonosítási mód nem működik, fontos, hogy egy különálló szkript doc_root-ot határozz meg, ami nem azonos a web doc_root-al.
A PHP szkript dokumentumok gyökérkönyvtárát a doc_root konfigurációs beállítással határozhatod meg a konfigurációs fájlban, vagy a PHP_DOCUMENT_ROOT környezeti változóban adhatod meg ezt az értéket. Ha ez be van állítva a PHP CGI verziója a fájl elérési útját a doc_root és a kérés elérési út információja (path information) alapján állítja elő, ami azt jelenti, hogy ezen a könyvtáron kívül nem futtatható fájl. (kivéve a user_dir esetét).
Egy másik itt használható opció a user_dir. Ha ez nincs megadva, csak a doc_root szabályozza a megnyitható fájlok körét. Ekkor egy http://domain.nev/~user/doc.php URL nem a "user" nevű felhasználó home könyvtárában lévő fájlt keresi, hanem a ~user/doc.php fájlt keresi a doc_root alatt (igen, egy tilde karakterrel kezdődő könyvtárban [~]).
Ha a user_dir meg van adva, például public_php, akkor a fenti http://domain.nev/~user/doc.php kérés a doc.php nevű fájlt fogja megnyitni a "user" nevű felhasználó home könyvtárában lévő public_php könyvtárban. Ha a "user" home könyvtára /home/user, a lefuttatandó fájl a /home/user/public_php/doc.php lesz.
A user_dir kifejtés a doc_root beállítástól függetlenül működik, úgyhogy a dokumentum gyökér és felhasználói könyvtár beállításokat külön is használhatod.
Rendkívül biztonságos lehetőség a PHP feldolgozót valahol a webről látható könyvtárakon kívülre tenni. Például az /usr/local/bin könyvtárba. Az egyetlen igazi hátránya ennek az opciónak az, hogy minden PHP szkript első sorának egy ehhez hasonló sort kell megadnod:
ami meghatározza, hogy hol található a PHP feldolgozó, ami lefuttatja majd ezt a kódot. Ráadásul minden PHP szkriptnek futási jogot kell adni. Azaz úgy kell eljárni, mint bármilyen más nyelven megírt CGI programmal, amit Perl, sh vagy és a #! shell-escape mechanizmust használja önmaga futtatására.Ahhoz, hogy ebben az esetben a PHP helyesen kezelje a PATH_INFO és a PATH_TRANSLATED információkat, a PHP feldolgozót az --enable-discard-path "configure" paraméterrel kell fordítani.
A PHP-t Apache modulként használva örökli az Apache-t futtató felhasználó (tipikusan a "nobody") jogait. Ennek többféle hatása van a biztonságra és az azonosításra. PHP-n keresztüli adatbázis elérés esetén például, az adatbázist elérhetővé kell tenni ezen felhasználó számára is, kivéve ha az adatbázisnak beépített azonosítása van. Ez azt jelenti, hogy egy rosszindulatú szkript elérheti, és módosíthatja az adatbázist, akár felhasználói név és jelszó nélkül is. Lehetséges, hogy egy keresőrobot beleakadjon az adatbázis-adminisztrációs oldalak egyikébe, és kiürítse az összes adatbázist. Természetesen lehet ez ellen védekezni Apache azonosítási technikákkal, vagy LDAP segítségével megvalósítotott saját elérési modellekkel, vagy külön .htaccess fájlokkal, stb., és ezeket a saját PHP kód részevé is lehet tenni így.
Általában, ha a biztonságot akkora szintre tudjuk emelni, hogy a PHP felhasználó (ebben az esetben az Apache-é) igen kis kockázattal fut, akkor nem képes például akármilyen fájlok írására a user könyvtárakba. Letilthatjuk számára egy adatbázis elérését vagy megváltoztatását. Tipikusan ebben a helyzetben már azokat a fájlokat sem tudja írni, amit kellene, vagy egyaránt nem tud végrehajtani jó és rosszindulatú adatbázis tranzakciókat egyaránt.
Gyakori hiba ezen a ponton, hogy az Apache-nak root jogokat adnak vagy valamilyen egyéb módon bővítik az Apache jogait / lehetőségeit.
Az Apache felhasználó jogainak root szintre bővítése különösen veszélyes, és tönkreteheti a teljes rendszert, tehát sudo, chroot vagy más hasonló eszközök használata elkerülendő, ha nem vagy biztonsági szakember.
Van néhány egyszerűbb megoldás is. Az open_basedir használatával szabályozni lehet, hogy mely könyvtárakat olvashatja a PHP. Ki lehet jelölni ún. csak apache-s területeket, hogy minden web alapú művelet ide, csak ezekre a nem rendszer- és nem felhasználói fájlokra korlátozódjon.
A PHP tiszteli a rendszerbe épített biztonsági megoldásokat, különös tekintettel a fájlok és könyvtárak hozzáférési jogosultságaira. Ez lehetőséget ad arra, hogy megszabd, mely fájlok olvashatóak a rendszerben. A mindenki számára olvasható fájloknál ügyelni kell arra, hogy ne tartalmazzanak olyan fontos adatot, amit nem szabad elolvasnia akármelyik felhasználónak a rendszeren.
Mivel a PHP úgy készült, hogy felhasználói szintű fájlrendszer hozzáférést ad, lehetséges olyan program készítése, amely a rendszerfájlokat olvassa, mint pl. az /etc/passwd fájl, ethernet kapcsolatokat módosít, nagyméretű nyomtatási feladatokat küld, stb. Ez maga után von egy nyilvánvaló következtetést, neveztesen minden esetben meg kell győződni a programokban arról, hogy a helyes fájlokat olvassa illetve írja a program.
Nézzük a következő szkriptet, ahol a felhasználó megadja, hogy le szeretne törölni egy fájlt a könyvtárában. Ez többnyire egy webes felületet jelent, ahol egy PHP program használatos fájlkezelésre, ezért az Apache-t futtató felhasználónak engedélyezni kell a fájlok törlését a felhasználó könyvtárában.
Csak korlátozott jogok beállítása a PHP-t futtató felhasználónak.
Minden felhasználótól bejövő adat ellenőrzése.
Példa 26-3. Biztonságosabb fájl ellenőrzés
|
Példa 26-4. Biztonságosabb fájlnév-ellenőrzés
|
A használt operációs rendszertől függően széles a védeni kívánt fájlok skálája, beleértve az eszköz hivatkozásokat (/dev/ vagy COM1), konfigurációs fájlokat (/etc/ és az .ini fájlok), jól ismert tárolóhelyek (/home/, My Documents), stb. E sokaság miatt könnyebb egy olyan rendszert készíteni, ahol mindent tiltunk azon kívül, amelyet kifejezetten megengedünk.
Mostanában, a dinamikus tartalmat szolgáltató web alkalmazások sarokkövének számítanak az adatbázisok. Mivel nagyon kényes, titkos adatok tárolására szolgálhatnak ezek az adatbázisok, erősen megfontolandó, miképp védjük meg ezeket.
Információk tárolásához vagy visszakereséséhez csatlakozni kell az adatbázishoz, egy érvényes lekérdezést kell küldeni, az eredményt ki kell olvasni, és le kell zárni a kapcsolatot. Manapság ebben a párbeszédben a Structured Query Language (SQL) a leggyakrabban használt lekérdezőnyelv. Figyeld meg, miként lehet SQL lekérdezéseket megbabrálni!
Mint látható, a PHP egymagában, magától nem képes megvédeni az adatbázist. A következő bekezdések célja, hogy betekintést adjanak az alapokba, hogyan kell adatbázisokat elérni és módosítani egy PHP programon belül.
Tartsd észben a következő egyszerű szabályt: tagoltan védekezni. Minél több helyen minél többet teszel a biztonság növeléséért, annál kisebb a valószínűsége, hogy a támadók sikerrel járjanak, és kiteregessék titkos adataidat, vagy visszaéljenek velük. A jó adatbázis- és alkalmazástervezés mindig a legnagyobb félelmek figyelembevételéről ismerszik meg.
Az első lépés mindig az adatbázis létrehozása, hacsak nem egy kívülállóét kell használni. Az adatbázis létrehozásakor az a tulajdonosáé lesz, azé, aki lefuttatta az utasításokat. Általában csak a tulajdonos - esetleg az ún. superuser - jogosult bármiféle az adatbázis elemeit érintő műveletre. Annak érdekében, hogy más felhasználók is hozzáférjenek, jogokat kell nekik biztosítani.
Az alkalmazásoknak soha nem szabad a tulajdonosaként vagy superuserként csatlakozni az adatbázishoz, mert ezek bármilyen utasítást és lekérdezést tetszés szerint futtathatnak, pl. a szerkezeti módosítást (táblák megszüntetése) vagy táblák komplett törlése.
Létre lehet hozni különböző, szigorúan korlátozott jogosultásgú adatbázis- felhasználókat, melyek mindegyike az adatbázis manipulációnak egy-egy különböző nézőpontjáért felelősek. Mindig csak a legszükségesebb jogokat szabad engedélyezni, és el kell kerülni, hogy ugyanazt a felhasználót használjuk szerepeiben egymástól különböző esetekben. Ez azt jelenti, hogy ha a behatoló meg is szerzi valamelyik ilyen minősítést (hitelesítési információt = felhasználói név + jelszó), akkor is csak akkora változást tud okozni, mint az alkalmazás maga.
Nem kell minden feladatfüggő szabályozást a webalkalmazásban (PHP szkriptben) kódolni, ehelyett inkább használd az adatbázis lehetőségeit: view-k (nézetek), trigger-ek, rule-ok (szabályok). Ha a rendszer fejlődik, és más alkalmazásokat is csatlakoztatni kell az adatbázishoz, akkor mindegyiknél újra kellene programozni ezeket a szabályokat. Mindezen felül a triggerek arra is jók, hogy átlátszó módon és automatikusan kezeljenek egyes mezőket az adatbázisban, amelyek gyakran bepillantást adnak abba, hogy mi is történik/történt egy tranzakció közben, vagy nagyon hasznosnak bizonyulhatnak hibakeresés során.
Elképzelhető, hogy SSL-n keresztül szeretnél kapcsolódni az adatbázishoz, hogy a kiszolgáló és ügyfél közti teljes kommunikáció titkosításával növeld a védelmet. Használhatsz ssh-t is erre a célra. Akármelyik is áll, nagyon nehéz lesz a forgalom lehallgatásából információkat kinyerni ezek után.
SSL/SSH az ügyfél és kiszolgáló közt mozgó adatokat védi, és nem védi az adatbázisban tárolt megmaradó adatokat. Az SSL - kapcsolati protokoll.
Mihelyst a támadó közvetlen hozzáférést szerzett az adatbázishoz - megkerülve a webszervert -, a tárolt adatok védtelenné váltak, és visszaélhet velük, ha csak maga az adatbázis nem védi valahogy azokat. Az adatok titkosítása kellőképp enyhíti ezt a veszélyt, de jelenleg nagyon kevés adatbázis kezelő támogatja a titkosítást.
Ez a legkönnyebben saját titkosító csomag írásával oldható meg, amelyet utána a PHP szkriptből el lehet érni. Ebben az esetben a PHP segítséget nyújthat néhány kiterjesztésével, mint például az Mcrypt vagy az Mhash, amelyek nagyon sokféle titkosító algoritmust fednek le. A szkript az adatbázisban való tárolás előtt titkosítja a tárolni kívánt adatot, majd visszakereséskor visszafejti azokat. Nézd meg a hivatkozott fejezeteket további példákért, hogyan kell a titkosítást végrehajtani.
Olyan teljesen rejtett adatok esetén, amelyeknek nyílt ábrázolásukra nincs szükség, mert nem lesznek kiíratva, a hashelés alkalmazása is meggondolandó. A hashelés jól ismert példája az, hogy a jelszavak helyett, azoknak csak MD5 hash értékét tárolják az adatbzisban. Lásd még: crypt() és md5()!
Példa 27-1. Hashelt jelszó mező használata
|
Sok web fejlesztő nincs tudatában annak, hogy hogyan lehet megbabrálni az SQL utasításokat, ezért az SQL utasításokat megbízható parancsoknak feltételezik. Ez azt jelenti, hogy az SQL lekérdezésekkel ki lehet játszani a hozzáférés szabályozásokat, meg lehet kerülni a szabályos engedélyezési folyamatokat , és néha az SQL lekérdezésekkel a gazdagépen operációs rendszer szintű hozzáférést is lehet létrehozni.
A "közvetlen SQL utasítás befecskendezés" olyan módszer, amellyel a támadó a régi SQL utasításokat módosítja vagy újakat ad hozzájuk annak érdekében, hogy titkos információkhoz jusson hozzá, vagy felülírja azokat, vagy veszélyes rendszer szintű parancsokat futtasson az adatbázis gazdagépén. Ez olyan alkalmazások esetén tehető meg, amelyek a felhasználótól származó adatokból és statikus paraméterekből állítanak össze SQL lekérdezéseket. Sajnos, a következő példák mind megtörtént eseteken alapulnak.
Az, hogy az adatbázishoz superuserként (olyan személyként, aki superusert képes létrehozni) csatlakozott az alkalmazás, és a bevitt adatok ellenőrzésének hiánya odavezethet, hogy a támadó superuser hozzáférést hozhat létre az adatbázishoz.
0;
insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd)
select 'crack', usesysid, 't','t','crack'
from pg_shadow where usename='postgres';
-- |
Megjegyzés: Általános módszer, hogy a -- jellel kényszerítik ki, hogy az SQL elemző figyelmen kívül hagyja a lekérdezésként átadott string fennmaradó részét, mivel ez a megjegyzés szabványos jelölése SQL-ben.
Egy lehetséges módja a jelszavak megszerzésének, hogy kijátszák a kereső oldalak találati listájának lekérdezéseit. A támadónak mindössze annyit kell tennie, hogy végig próbálja melyik elküldött SQL lekérdezésben használt változó nincs megfelelően lekezelve. Ezeket általában egy megelőző űrlapon lehet beállítani, hogy testre szabjuk a SELECT utasítás WHERE, ORDER BY, LIMIT és OFFSET klauzuláit. Ha a használt adatbáziskezelő támogatja a UNION szerkezetet, akkor a támadó esetleg hozzáfűzhet egy teljesen új lekérdezést a már meglevőhöz, hogy kilistázza valamelyik táblában tárolt jelszavakat. Titkosított tárolás erősen ajánlott!
SQL UPDATE parancsok ugyancsak ki vannak téve az adatbázisok elleni támadásoknak. Ezeket az utasításokat is fenyegetik az előzőekben megismert megrövidítő és hozzáfűző technikák. Ám emellett a támadó meghamisíthatja a SET klauzulát is. Ebben az esetben némi séma információval rendelkeznie kell a támadónak, hogy sikerrel járjon. Ezeket az információkat az űrlapváltozók neveiből szerezhetik meg, vagy egyszerűen próbálgatással. Az általánosan használt elnevezések a felhasználói névre és jelszóra nem nagyon különböznek egymástól.
// $uid == "' or uid like'%admin%'; --" $query = "UPDATE usertable SET pwd='...' WHERE uid='' or uid like '%admin%'; --';"; // $pwd == "hehehe', admin='yes', trusted=100 " $query = "UPDATE usertable SET pwd='hehehe', admin='yes', trusted=100 WHERE ..."; |
Egy ijesztő példa, hogyan lehet az adatbázis gazdagépén operációs rendszerszintű parancsokat futtatni.
$query = "SELECT * FROM products
WHERE id LIKE '%a%'
exec master..xp_cmdshell 'net user test testpass /ADD'--%'";
$result = mssql_query($query); |
Megjegyzés: A példák némelyike bizonyos adatbáziskezelőhöz kötődik. Ez nem azt jelenti, hogy hasonló támadás elképzelhetetlen más termékek ellen. Az általad használt adatbázis-kezelő ugyanilyen sérülékeny lehet, akár más módon.
Ellenevetésként felmerülhet, hogy a példák többségében a támadónak rendelkeznie kell valamennyi előzetes információval az adatbázis felépítéséről. Ez igaz, de soha nem lehet tudni, hogy mikor, hol, hogyan szerezhetik meg ezeket, és ha ez megtörtént, az adatbázisod védtelenné válik. A behatolók könnyen hozzájuthatnank a program egy darabjához nyílt forráskódú, vagy olyan nyilvánosan elérhető adatbázis-kezelő programcsomag használatakor, amelyik egy fórum vagy tartalomszolgáltató rendszer része. Ez különösen veszélyes lehet, ha ezek kevéssé átgondoltak és gyengén megtervezettek.
Ezek a támadások alapvetően olyan programoknak a kijátszásán alapulnak, amelyek a védelmet/biztonságot figyelmen kívül hagyva születtek. Soha nem lehet megbízni semmilyen bejövő adatban, főleg ha az a kliens oldalról érkezik, még akkor sem, ha az egy általunk megadott süti (cookie), vagy rejtett mező (hidden input) értéke esetleg egy legördülő lista eleme. Még egy olyan ártatlan lekérdezés, mint ami az első példában látható, katasztrófát okozhat.
Soha ne csatlakozz az adatbázishoz tulajdonosaként vagy superuser-ként. Mindig kevés jogosultsággal rendelkező, testreszabott felhasználókat használj!
Ellenőrizd a bejövő adat típusát, hogy az a vártnak megfelelő-e! A PHP a bevitelt ellenőrző függvények széles körével rendelkezik kezdve a legegyszerűbbektől - pl.: Változókkal kapcsolatos függvények közül is_numeric() vagy a Character Type Functions közül a ctype_digit() - a Perl kompatibilis reguláris kifejezések támogatásáig.
Ha az alkalmazás számot vár, akkor megfontolandó az is_numeric() függvénnyel ellenőrizni a típusát, vagy csendben megváltoztatni a típusát a settype() függvénnyel, vagy szám szerinti ábrázolását használni az sprintf() függvénnyel.
Példa 27-6. A lapozáshoz használt lekérdezés összeállításának biztonságosabb módja
|
Idézőjelek közé kell tenni minden nem szám jellegű, felhasználótól származó adatot, erre használható az adatbázis-specifikus escape függvény (pl. mysql_escape_string(), sql_escape_string(), stb.). Ha nincs ilyen adatbázis-specifikus escape mechanizmus, akkor hasznosnak bizonyulhatnak az addslashes() és a str_replace() függvények (az adatbázistól függően). Lásd még az első példát! Ahogy a példa is mutatja, a statikus részbe beírt idézőjelek nem elegendőek, mivel ez a lekérdezést könnyen feltörhetővé teszi.
Semmilyen adatbázisra jellemző információt - különösen szerkezetit - nem szabad kiírni, ha törik, ha szakad. Lásd még: Hibajelzés és Hibakezelő és naplózó függvények!
Tárolt eljársokat és előre definiált kurzorokat is használhatsz, hogy az adatbázis elérést absztraháld annak érdekében, hogy a felhasználók ne közvetlenül a táblákhoz vagy nézetekhez férjenek hozzá. Ennek a megoldás azonban egyéb hatásai vannak.
Ezeken kívül, hasznot hajthat a lekérdezések naplózása akár a szkripteken belül, akár ha az adatbázis kezelő maga teszi ezt. Nyilvánvalóan ez nem tud megakadályozni egyetlen ártalmas próbálkozást sem, de segítséget nyújthat annak felderítésében, hogy melyik alkalmazás lett kijátszva. A naplózás önmagában nem, csak a benne megjelenő információkon keresztül válik hasznossá: általában a több részlet, hasznosabb.
A PHP biztonsági kérdések felől a hibajelzéseknek két oldaluk van. Az egyiket nézve hasznos a védelem növelése szempontjából, a másik szemszögből viszont káros.
Egy szokásos támadási technika minél több információ begyűjtése a rendszerről. Ezt úgy próbálják megoldani, hogy helytelen adatokat küldenek be, és rögzítik a hibaüzenetek típusait és környezetüket. Ez lehetőséget ad a crackernek, hogy elég információt gyűjtsön a rendszerről, és meghatározza a lehetséges gyenge pontokat. Ha például a támadó összeszedegetett elég információt az előző űrlap kitöltések alapján, akkor megpróbálhatja a változókat felülírni vagy megváltoztatni őket:
A PHP által visszaadott hibaüzenetek általában hasznosak a hibákat kereső fejlesztő számára, megjelölve a fájlt, és a függvényt, ami hibás, megadva a megfelelő programsor számát. Ez az összes információ, amit ki lehet nyerni. Nem ritka, hogy egy PHP fejlesztő a show_source(), highlight_string(), vagy highlight_file() függvényeket a fejlesztés során hibakeresésre is használja, de egy élesben lévő webhelyen ez rejtett változókat, ellenőrizetlen kódokat, és más veszélyes információkat fedhet fel. Kifejezetten veszélyes beépített hibakezelővel rendelkező ismert forrású kódok használata. Ha a támadó ráismer valamilyen általános programozási technikára, akkor megpróbálhatja a nyers erőre alapozva feltörni az oldalt a különböző megszokott hibakereső (debugging) változók elküldésével:
A hibakezelés módjától függetlenül az a lehetőség, hogy egy rendszerben hibák után kuthatnak, odavezet, hogy a támadók is több információhoz jutnak.
Az általános hibaüzenetek nagyrészéből például beazonosítható, hogy a rendszer PHP-t használ. Ha a támadó egy .html oldalt látott, és ismert hibákat kihasználva meg akarta tudni, hogy milyen alkalmazást használ a rendszer, hibás adatokat beküldve azonosíthatja, hogy az oldalt egy PHP program állította elő.
Egy függvényhiba elárulhatja, hogy a rendszer milyen adatbázismotort használ, vagy hogy milyen programozói stílussal készült az adott weblap. Ez mélyebb kutatásokra ad lehetőséget nyitott adatbázisportok irányában, vagy tipikus hibák illetve gyengeségek keresését jelentheti. Különböző hibás adatok küldésével a támadó meg tudja állapítani, hogy milyen sorrendben végzed az azonosításokat (a hibák sorszámaiból). Ezzel a gyenge pontok is könnyen megtalálhatóak egy szkriptben.
A fájlrendszer vagy általános PHP hibák jelezhetik, hogy milyen jogokkal rendelkezik a webszerver, és megmutathatják a fájlok elrendezését és struktúráját. A fejlesztő által írt hibás kód súlyosbíthatja a helyzetet, egykori 'rejtett' információk könnyű kiderítését téve lehetővé.
Három megoldási lehetőség adódik erre a problémára. Az első, megvizsgálni alaposan a függvényeket, és megpróbálni elkerülni a hibákat. A második a a hibajelzés kikapcsolása a teljes kódon belül. A harmadik a PHP testreszabható hibajelentési funkcióinak használata, hogy saját hibakezelőket definiálj. A már megtett biztonsági intézkedésektől függően esetleg mindhárom fenti módszert választható.
Megelőzendő a bajt hasznot hajthat a PHP beépített error_reporting() függvénye, amely segít biztonságosabbá tenni a programokat és megtalálni a változók vészelyeket rejtő használati formáit. A bevezetés előtti tesztelés során E_ALL beálllítással gyorsan meg lehet találni azokat a pontokat, ahol a változók könnyen és/vagy rosszindulatúan módosíthatók. Ha a program már kész bevezetésére, teljesen kikapcsolhatod a hibajelentést az error_reporting() 0-ra állításával, vagy kikakpcsolod a hibák megmutatását a php.ini display_errors opciójával, ezzel teljesen leszigetelve a kódot a további vizslatásoktól. Ha az utóbbit választod, meg kell adnod a naplófájl útvonalát az error_log ini direktívával, majd a log_errors direktívát on-ra kell állítanod.
Példa 28-3. Veszélyes változók felderítése az E_ALL segítségével
|
A legvitatottabb változtatás a PHP-ben talán az, amikor register_globals direktíva alapértelmezett értéke ON-ról OFF-ra változott a PHP 4.2.0-ban. Erre a direktívára való támaszkodás meglehetősen népszerű volt, sokan még azt sem tudták, hogy létezik és azt feltételezték, hogy ez csupán a PHP működésének tudható be. Ez az oldal azt taglalja, hogyan lehet nem biztonságos kódot írni ezzel a direktívával, de tartsd észben azt is, hogy maga a direktíva nem veszélyes, annál inkább az a helytelen használata.
Amikor a register_globals be van állítva, megmérgezi a szkriptjeidet mindenféle változóval, mint például a HTML formokból származókkal. Ehhez hozzájön az, hogy a PHP nem követeli meg a változók inicializálását, így sokkal könnyeb veszélyes kódot írni. Nehéz döntés volt, de a PHP közösség úgy döntött, hogy ez a direktíva alap állapotban ki kell legyen kapcsolva. Amikor bekapcsolt állapotban van, úgy használják a változókat, hogy valójában nem is tudják honnan származik, csak feltételezik. A szkriptben definiált változók összekeverednek a felhasználótól érkezőkkel, de a register_globals kikapcsolása ezt megváltoztatja. Itt egy példa, amely a register_globals helytelen használatát szemlélteti:
Példa 29-1. Helytelen használat register_globals = on esetben
|
Amikor register_globals = on, a fenti logikánkon kicsit javítani kell. Amikor off, a $jogosult változó nem állítható be a felhasználótól érkező adatokból, tehát minden rendben, bár valójában a változók inicializálása rendszerint jó programozási gyakorlat. Például a fenti kódrészletben előbb egy $jogosult = false értékadást kellett volna írnunk. Ha így teszünk, a kódunk működik a register_globals on és off értékével egyaránt, azaz a felhasználók alapból jogosulatlanok lesznek.
Egy másik példa a munkamenetkezeléshez kötődik. Amikor register_globals = on, az alábbi példában használhatnánk egy $usernev változót, de gondolj bele, hogy a $usernev máshonnan is származhat, mint például GET paraméterből (URL-en keresztül).
Példa 29-2. Példa munkamenetek használatára, register_globals on vagy off
|
Okosan használva, még azt képes lehet jelezni, ha hamisítást kíséreltek meg. Ha előre tudható, hogy mely változóknak honnan kell érkezniük, akkor azt is megvizsgálhatod, hogy vajon más módon nem próbálták-e elküldeni ezt a változót. Ez nem garantálja, hogy az adatok nem hamisíthatók, azonban megköveteli a támadótól, hogy az rátaláljon a megfelelő hamisítási módszerre. Az is lehetséges, hogy megelőző intézkedéseket tegyünk, hogy figyelmeztetést kapjunk, amikor hamisítást kíséreltek meg. Ha előre tudható, hogy mely változóknak pontosan honnan kell érkezniük, akkor azt is megvizsgálhatod, hogy vajon más módon nem próbálták-e elküldeni ezt a változót. Ez nem garantálja, hogy az adatok nem hamisíthatók, azonban megköveteli a támadótól, hogy az rátaláljon a megfelelő hamisítási módszerre. Ha nem számít, hogy a beküldött adat honnan jön, használhatod a $_REQUEST-et, mivel ez tartalmazza a GET, POST és COOKIE adatok keverékét. Lásd még a kézikönyv PHP-n kívüli változók használatáról szóló részt.
Példa 29-3. Egyszerű "változómérgezés" feltárása
|
A register_globals kikapcsolása természetesen nem jelenti azt, hogy a kódod biztonságos. Minden beérkező adatot valamilyen egyéb módon is ellenőrizni kell. Mindig ellenőrizd a felhasználótól érkező adatokat és inicializáld a változóidat! Az inicializálatlan változók felfedezéséhez bekapcsolhatod az error_reporting()-ot hogy kiírja az E_NOTICE szintű hibákat.
A FAQ-ban olvashatsz arról, hogyan lehet emulálni a register_globals On vagy Off értékét.
A szuperglobális változók használhatósága: A 4.1.0 változattól kezdődően bevezetésre kerültek olyan szuperglobális hatókörű tömbök, mint a $_GET, $_POST, $_SERVER, stb. További infórmációk a superglobals oldalon olvashatók.
A legtöbb probléma sok PHP programban nem a nyelvben rejlik, hanem abból fakad, hogy a kód nem a biztonságosságot szem előtt tartva készült. Emiatt mindig kellő időt kell szánni annak ellenőrzésére, hogy egy adott kódrészletre milyen hatással lehet egy váratlan hibás adat.
Példa 30-1. Veszélyes változóhasználat
|
Biztos, hogy ez a szkript csak a kívánt fájlokat fogja módosítani?
Előfordulhat egy ponton, hogy szokatlan vagy nem kívánatos adat jelenjen meg?
Használható-e az adott szkript nem kívánatos formában?
Felhasználható-e más szkriptekkel együtt egy negatív hatás elérésére?
Megfelelően naplózásra kerülnek-e a tranzakciók (elérések, változtatások)?
Számításba lehet venni a register_globals, magic_quotes és más kényelmi szolgáltatások kikapcsolásának a gondolatát is, mivel ezek megfosztanak az adatok forrásának, helyességének, tartalmának ismeretétől. A PHP*t maximális hibajelentési szinten használva - az error_reporting E_ALL beállításával - figyelmeztetést ad előzetes érték nélküli, definiálatlan változókról, ezzel védve attól, hogy véletlenül hibás adatokkal dolgozzon a program.
Magic Quotes is a process that automagically escapes incoming data to the PHP script. It's preferred to code with magic quotes off and to instead escape the data at runtime, as needed.
When on, all ' (single-quote), " (double quote), \ (backslash) and NULL characters are escaped with a backslash automatically. This is identical to what addslashes() does.
There are three magic quote directives:
Affects HTTP Request data (GET, POST, and COOKIE). Cannot be set at runtime, and defaults to on in PHP.
See also get_magic_quotes_gpc().
If enabled, most functions that return data from an external source, including databases and text files, will have quotes escaped with a backslash. Can be set at runtime, and defaults to off in PHP.
See also set_magic_quotes_runtime() and get_magic_quotes_runtime().
If enabled, a single-quote is escaped with a single-quote instead of a backslash. If on, it completely overrides magic_quotes_gpc. Having both directives enabled means only single quotes are escaped as ''. Double quotes, backslashes and NULL's will remain untouched and unescaped.
See also ini_get() for retrieving its value.
Useful for beginners
Magic quotes are implemented in PHP to help code written by beginners from being dangerous. Although SQL Injection is still possible with magic quotes on, the risk is reduced.
Convenience
For inserting data into a database, magic quotes essentially runs addslashes() on all Get, Post, and Cookie data, and does so automagically.
Portability
Assuming it to be on, or off, affects portability. Use get_magic_quotes_gpc() to check for this, and code accordingly.
Performance
Because not every piece of escaped data is inserted into a database, there is a performance loss for escaping all this data. Simply calling on the escaping functions (like addslashes()) at runtime is more efficient.
Although php.ini-dist enables these directives by default, php.ini-recommended disables it. This recommendation is mainly due to performance reasons.
Inconvenience
Because not all data needs escaping, it's often annoying to see escaped data where it shouldn't be. For example, emailing from a form, and seeing a bunch of \' within the email. To fix, this may require excessive use of stripslashes().
The magic_quotes_gpc directive may only be disabled at the system level, and not at runtime. In otherwords, use of ini_set() is not an option.
Példa 31-1. Disabling magic quotes server side An example that sets the value of these directives to Off in php.ini. For additional details, read the manual section titled How to change configuration settings.
If access to the server configuration is unavailable, use of .htaccess is also an option. For example:
|
In the interest of writing portable code (code that works in any environment), like if setting at the server level is not possible, here's an example to disable magic_quotes_gpc at runtime. This method is inefficient so it's preferred to instead set the appropriate directives elsewhere.
Példa 31-2. Disabling magic quotes at runtime
|
Általában a rejtegetésen és félrevezetésen alapuló védelem az egyik leggyengébb formája a védekezésnek, azonban néha minden apró többlet kívánatos lehet.
Néhány egyszerű módszerrel elrejthető, hogy PHP-t használsz, így lassítva le a támadót, aki fel akarja deríteni a rendszer gyenge pontjait. A php.ini-ben az expose_php = off beállítással csökkentheted ezeket az információkat.
Másik taktika a webszerver (pl. apache) olyan beállítása a .htaccess-en vagy az apache konfigurációs fájlában, hogy különböző típusú fájlokat is PHP-n keresztül futtasson. Más félrevezető fájlkiterjesztések alkalmazására példa:
A PHP, mint bármilyen más nagy rendszer állandóan változások és fejlesztések alatt áll. Minden új változat kisebb-nagyobb változtatásokat tartalmaz, feljesztve a nyelvet, kijavítva biztonsági hibákat, beállítási kellemetlenségeket, és más olyan elemeket, amik a teljes rendszer stabilitására és biztonságára hatnak.
Mint más rendszerszintű nyelvek és programok esetében, a legjobb hozzáállás a gyakori frissítés, valamint a friss változatokról, és a fellépő változásokról való informálódás.
A HTTP hitelesítési (authentication) funkciók csak akkor elérhetőek PHP-ben, ha az Apache modulként fut, bár régebben ez a CGI módú használat során is működött, azonban ez a lehetőség már megszűnt. Az Apache modulként futó PHP esetében a header() függvényt kell használni arra, hogy egy "Authentication Required" üzenetet küldjön a kliens böngészőnek, aminek hatására az egy Username/Password bemeneti ablakot nyit meg a felhasználó számára. Ha a látogató kitöltötte a username és password mezőket, az URL, ami a PHP szkriptre mutat, ismét meghívásra kerül, és rendelkezésre állnak a PHP_AUTH_USER, PHP_AUTH_PW és a AUTH_TYPE változók, amik a felhasználói név, jelszó és azonosítási típus értékeket tartalmazzák értelemszerűen. Mind a "Basic", mind a "Digest" (PHP 5.1.0 óta) azonosítási típus támogatott. További információt a header() függvény dokumentációjában találsz.
PHP verziókhoz kötödő megjegyzés: Az autoglobális változók, mint például a $_SERVER, a PHP 4.1.0 változatától elérhetőek. PHP 3-ban helyette a HTTP_SERVER_VARS használható.
Egy egyszerű példa PHP szkript, ami kliens azonosítást vált ki:
Példa 34-1. HTTP azonosítási példa (Basic)
|
Példa 34-2. HTTP azonosítási példa (Digest) Az alábbi példamutatja be, hogy lehet összeállítani egy Digest típusú HTTP azonosítást végző szkriptet. A dologról bővebb információkat az RFC 2617 leírásában találsz.
|
Megjegyzés: Vigyázni kell a HTTP fejlécek írásakor! A maximális kompatibilitás eléréséhez a "Basic" kulcsszót nagy B betűvel kell kezdeni, a "realm" részt mindenképpen idézőjelbe (és nem aposztrófok közé) kell tenni! Végül pontosan egy szóközt hagyj ki a "401" előtt a "HTTP/1.0 401" fejléc sorban.
Egy valós esetben persze nem a $PHP_AUTH_USER és $PHP_AUTH_PW kiírása az elérni kívánt cél, így általában a felhasználói név és jelszó ellenőrzése következik. Természetesen lehetőség van ezt egy adatbázis lekérdezéssel megoldani, vagy egy dbm fájlban utánanézni a szükséges adatoknak.
Figyelj az Internet Explorer böngészők hibáira, ezek nem fogadják el tetszőleges sorrendben a HTTP fejléceket. A tesztek azt mutatják, hogy a WWW-Authenticate elküldése a HTTP/1.0 401 előtt megoldja a problémát.
Mivel a hagyományos HTTP azonosítás során a PHP 4.3.0-ás változatától kezdődően a jelszó rejtett az elért szkript előtt, a PHP nem állítja be a PHP_AUTH változókat ha az adott file-ra ha hagyományos azonosítás is engedélyezett és a ??? bekapcsolt állapotban van. Így nem deríthető ki a user jelszava. Ebben az esetben a REMOTE_USER változó tartalmazza a már azonosított felhasználó nevét, azaz $_SERVER['REMOTE_USER']-ként férhetünk hozzá.
Beállítási megjegyzés: A PHP az AuthType direktíva megléte alapján dönti el, hogy rajta kívülálló azonosítás történik-e.
Vedd észre, hogy ez nem küszöböli ki azt a problémát, hogy más nem azonosítás-köteles URL címeken lévő szkriptek ugyanazon a szerveren megszerezzék a jelszavakat az azonosított URL-ekről.
A Netscape Navigator és Internet Explorer böngészők törölni fogják a böngésző adott oldalhoz tartozó azonosítási tárát (authentication cache), amennyiben egy 401-es szerver üzenetet kapnak. Ez gyakorlatilag kilépteti a user-t, ami azt jelenti, hogy legközelebb ismét meg kell adnia a nevét és jelszavát. Időnként ezt arra használják, hogy lejárati időt rendelve a belépésekhez egy idő után megszüntessék azokat, vagy egy kilépés gombot biztosítsanak.
Példa 34-3. HTTP azonosítási példa, ami új nevet és jelszót kér
|
A HTTP Basic azonosítási standard nem követeli meg ezt a viselkedést a böngészők részéről, tehát ne építs rá! Lynx-el végzett tesztek azt mutatták, hogy a Lynx nem törli az azonosítási bizonyítványokat a 401-es szerver válasz hatására, tehát egy back és forward lépéssel ismét megnyílik az oldal, feltéve, hogy az azonosítási feltételek nem változtak. Ellenben a felhasználó megnyomhatja a '_' billentyűt, hogy törölje az azonosítási információkat.
Szintén fontos megjegyezni, hogy ez a módszer nem vezet eredményre (A PHP 4.3.3 változatáig bezárólag), ha Microsoft IIS szervert használsz CGI módú PHP-val, az IIS korlátai miatt. Ahhoz, hogy ezt a PHP 4.3.3 változatától kezdve használhasd, bele kell kicsit nyúlni az IIS beállításaiba. A "Directory Security" beállításainál kattints az "Edit" gombra és csak az "Anonymous Access"-t hagyd bekapcsolva.
Egy másik korlátozása az IIS (ISAPI) modulnak, hogy a PHP_AUTH_* változók nem kapnak értéket. Helyette a HTTP_AUTHORIZATION áll rendelkezésre. Egy kis példakód ötletképpen: list($user, $pw) = explode(':', base64_decode(substr($_SERVER['HTTP_AUTHORIZATION'], 6)));
Megjegyzés az IIS kapcsán:: Ahhoz, hogy a HTTP azonosítás működjn IIS alatt, 0-ra kell állítani a cgi.rfc2616_headers PHP konfigurációs direktíva értékét (ez az alapértelmezett értéke).
Megjegyzés: Ha safe mode be van kapcsolva, akkor a WWW-Authenticate fejléc realm részéhez a szkript UID-ja is hozzáadódik. the header.
A PHP támogatja a HTTP cookie-k kezelését. A sütik lehetőséget adnak arra, hogy adatokat tárolj a kliens gépen, így követve vagy azonosítva a visszatérő látogatókat. Sütik beállítására a setcookie() vagy a setrawcookie() függvénnyel nyílik lehetőség. A sütik részei a HTTP fejlécnek, így a setcookie() függényt azelőtt kell meghívni, mielőtt bármilyen kimenetet küldesz a böngészőnek. Ez a header() függvénnyel megegyező korlátozást jelent. A kimenet szabályozó függvényeket használhatod a kimenet késleltetésére addig, amíg minden sütit és fejlécet elküldtél.
Minden süti, amit a klienstől visszakapsz, automatikusan PHP változóvá válik, pont úgy, mint a GET és a POST kérésekkel érkező adatok, feltéve, hogy a register_globals és variables_order php.ini beállítások ennek megfelelően vannak beállítva. Ha több értéket szeretnél adni egy sütinek, add a szokásos [] végződést a süti nevéhez.
A PHP 4.1.0 és későbbi változataiban a $_COOKIE nevű mindenhonnan látható változó mindig létrejön, tartalmazva a klienstől érkezett sütiket. A $HTTP_COOKIE_VARS a korábbi verziókban használható, ha a track_vars php.ini beállítás be van kapcsolva, bár ez a változó nem látszik mindenhonnan. (A 4.0.3-as változattól felfele ez mindig be van kapcsolva)
Részletesebb információk, beleértve a böngésző hibákat, a setcookie() setrawcookie() függvények dokumentációs oldalain olvashatók.
Session support in PHP consists of a way to preserve certain data across subsequent accesses. This enables you to build more customized applications and increase the appeal of your web site. All information is in the Session reference section.
XForms defines a variation on traditional webforms which allows them to be used on a wider variety of platforms and browsers or even non-traditional media such as PDF documents.
The first key difference in XForms is how the form is sent to the client. XForms for HTML Authors contains a detailed description of how to create XForms, for the purpose of this tutorial we'll only be looking at a simple example.
Példa 37-1. A simple XForms search form
|
The above form displays a text input box (named q), and a submit button. When the submit button is clicked, the form will be sent to the page referred to by action.
Here's where it starts to look different from your web application's point of view. In a normal HTML form, the data would be sent as application/x-www-form-urlencoded, in the XForms world however, this information is sent as XML formatted data.
If you're choosing to work with XForms then you probably want that data as XML, in that case, look in $HTTP_RAW_POST_DATA where you'll find the XML document generated by the browser which you can pass into your favorite XSLT engine or document parser.
If you're not interested in formatting and just want your data to be loaded into the traditional $_POST variable, you can instruct the client browser to send it as application/x-www-form-urlencoded by changing the method attribute to urlencoded-post.
Példa 37-2. Using an XForm to populate $_POST
|
Megjegyzés: As of this writing, many browsers do not support XForms. Check your browser version if the above examples fails.
Ez a szolgáltatás egyaránt lehetővé teszi a látogatónak szöveges és bináris fájlok feltöltését. A PHP azonosítási és fájlkezelési képességeivel teljes felügyeletet lehet gyakorolni afelett, hogy ki tölthet fel állományokat, és azokkal mi történjen.
A PHP alkalmas fájl feltöltést fogadni bármilyen RFC-1867 kompatibilis böngészőtől (mint a Netscape Navigator 3 vagy későbbi és a Microsoft Internet Explorer 3 Microsoft javítással, vagy későbbi IE javítás nélkül).
Kapcsolodó konfigurációs megjegyzés: Lásd még: file_uploads, upload_max_filesize, upload_tmp_dir, post_max_size és a max_input_time direktívákat a php.ini-ben!
A PHP támogatja a PUT metódust is, amit a Netscape Composer és a W3C Amaya kliensek használnak. Lásd a PUT metódusú feltöltések részt.
Példa 38-1. Állományfeltöltő űrlap Az állomány feltöltési lehetőség egy különleges módon kialakított űrlappal biztosítható, amely nagyjából így néz ki:
A példában szereplő _URL_ a feldolgozást végző PHP fájlra kell, hogy mutasson. A MAX_FILE_SIZE rejtett mező a file típusú input mező előtt kell, hogy szerepeljen, és azt adja meg, hogy mekkora a maximális fájl méret (byte-okban megadva), amit a kliens jogosult feltölteni. Ez csak egy javasolt érték a böngészők számára, amit a PHP még szintén felülvizsgálhat. A böngésző oldalon ezt az értéket igen könnyű megnövelni, ezért céleszerű minden esetben a PHP-vel is a fájlok körmére nézni a méret tekintetében. Ellentétben az űrlapban beállítottal a PHP beállítása szerinti maximum méretet nem lehet semmi esetre sem túllépni semmilyen trükkel sem. Mindenesetre érdemes ezt a maximum értéket értéket az űrlapba helyezni, hogy az átlagfelhasználó ne várjon feleslegesen perceket arra hogy kiderüljön, túl nagy fájlt akar a szerverre tukmálni. |
Megjegyzés: Fontos, hogy a fájlfeltöltő űrlapokban szerepeljen a enctype="multipart/form-data" meghatározás is, ellenkező esetben a feltöltés nem fog működni.
A PHP 4.1.0-ás változata óta létezik a $_FILES globálisan elérhető tömb (korábbi változatokban használd a $HTTP_POST_FILES tömböt). Ez a tömb tartalmazza a feltöltött fájlok minden adatát.
A $_FILES tartalma a fenti példa alapján a következő. Megjegyezndő, hogy az alábbi felsorolás arra épít, hogy a az állomány feltölő mező neve userfile, ahogy a fenti példában látható. Ennek természetesen mi bármilyen más nevet is adhatunk.
Az állomány eredeti neve a távoli kliensgépen.
A feltöltött állomány MIME típusa, ha a böngésző átadta ezt az információt, pl.: "image/gif".
A feltöltött állomány mérete bájtokban.
Annak az ideiglenes állománynak a neve, amely a szerveren tárolja a feltöltött állomány tartalmát.
Az állomány feltöltés során keletkezett hiba kódja. A PHP 4.2.0 változatától használható.
Az állományok alapbeállításban a szerver szokásos ideiglenes könyvtárában tárolódnak, ha nem adtál meg mást az upload_tmp_dir beállítással a php.ini fájlban. A szerver alapbeállítású könyvtára megváltoztatható a TMPDIR környezeti változóval abban a környezetben, ahol a PHP fut. PHP szkriptből a putenv()-el való átállítás nem működik. Ez a környezeti változó annak ellenőrzésére is használható, hogy más műveletek is végezhetőek-e a feltöltött állományokon.
Példa 38-2. Fájlfeltöltések ellenőrzése Érdemes még rátekinteni az is_uploaded_file() és a move_uploaded_file() függvényekre is. Az itt következő példa egy űrlap által kezdeményezett fájlfeltöltést fog lekezelni.
|
A PHP programnak, amely megkapja a feltöltött állományt, gondoskodnia kell arról is, hogy a kívánt műveleteket elvégezze az állománnyal. Például törölheti azt, ha az túl nagy, vagy túl kicsi, figyelembe véve a $_FILES['userfile']['size'] változó értékét, vagy meghatározhatja a $_FILES['userfile']['type'] alapján, hogy ez a fájl megfelel-e egy meghatározott fájltípusnak, és ha nem, törölheti. PHP 4.2.0-től kezdve a $_FILES['userfile']['error'] használható arra, hogy a hibakódoknak megfelelően változzon szkript működését. Bármi is legyen a cél a feltöltött állománnyal, a PHP szkriptnek kell gondoskodnia arról, hogy elmozgassa egy biztonságos helyre, vagy törölje az ideiglenes könyvtárból az adott ideiglenes állományt.
Ha az űrlapban nem lett fájl kijelölve feltöltésre, a PHP a $_FILES['userfile']['size'] értékeként 0-át ad vissza, valamint a $_FILES['userfile']['tmp_name'] tartalma "none" lesz.
Az ideiglenes állomány törlésre kerül az ideiglenes könyvtárból a kérés végrehajtásának végeztével, ha nem lett elmozgatva vagy átnevezve.
Példa 38-3. Példa: Több fájl feltöltése egy tömbben A PHP támogatja a HTML adattömbök használatát fájl típusú űrlapelemek esetén is.
|
PHP 4.2.0-tól kezdve PHP az állományhoz tartozó tömbben a megfelelő hibakódot is visszaadja. Ezt a hibakódot a feltöltéskor létrehozott tömb error eleme tárolja. Másképp megfogalmazva, a hiba a $_FILES['userfile']['error'] hivatkozás értékeként olvasható ki.
érték: 0; nincs hiba, a feltöltés sikerült.
érték: 1; a feltölteni kívánt fájl túl nagy a php.ini-ben megadott upload_max_filesize direktíva által megengedetthez képest.
érték: 2; a feltölteni kívánt fájl túl nagy a HTML űrlapban megadott MAX_FILE_SIZE értékhez képest.
érték: 3; az állomány csak részben lett feltöltve.
érték: 4; nem történt állomány-feltöltés.
érték: 6; Az átmeneti tárolókönyvtár nem létezik. (PHP 4.3.10 illetve 5.0.3-tól lett bevezetve)
Megjegyzés: Ezek állandókként is használhatók PHP 4.3.0-tól kezdve.
A MAX_FILE_SIZE nem tartalmazhat nagyobb értéket, mint az upload_max_filesize beállítás értéke. Az alapbeállítás 2 megabyte.
Ha a memóriakorlát be van állítva, esetleg növelni kell a memory_limit értékét. Gondoskodni kell a memory_limit kellően nagyra állításáról!
Ha a max_execution_time túl kicsire van állítva, a program futása során letelhet az idő. Ezért gondoskodni kell a max_execution_time kellően nagyra állításáról! Az állományok feltöltése nem számít bele a max_execution_time időbe, de egy nagyobb állomány feldolgozása lehetséges, hogy több időt vesz igénybe a program számára.
Megjegyzés: A max_execution_time csupán csak a szkriptek lefutásának idejére vonatkozik. Minden olyan tevékenység, amely a szkript futásán kívül történik, mint például a system(), sleep() függvényhívás, az adatbázis lekérések feldolgozása adatbázis oldalon, vagy történetesen a fájfeltöltés ideje nem számít bele a futtatási időbe.
| Figyelem |
A max_input_time adja meg másodpercekben azt a leghosszabb időt, amennyi időt a szkript eltölthet az adatok átvételével. Ilyen a fájlfeltöltés is. Nagyobb állományok feltöltése esetén nem árt, ha a PHP által alapértelmezett 60 másodperces időtt nagyobbra állítjuk. |
Ha a post_max_size túl kicsi, nagy állományok nem tölthetőek fel. Gondoskodni kell a post_max_size kellően nagyra állításáról!
Ellenőrizni kell mindig, hogy pontosan mely állományokon végez műveletet a program. A felhasználók esetleg más könyvtárakhoz is hozzáférhetnek.
A CERN httpd szerver úgy tűnik, hogy eldob mindent a klienstől kapott Content-type MIME fejlécben az első szóközt követően. Amíg ez fennáll, a CERN httpd szerver nem fogja támogatni a fájl feltöltéseket.
Köszönhetően a nagyon sokféle állomány elnevezési lehetőségnek, konvenciónak nam garantálható, hogy a különleges nevű (pl. szóközt tartalmazó) állományok feltöltése mindig a megfelelően működik.
A fájl típusú adatok nem keverhetőek közös tömbbe más, normál adatokkal (az ize[] elnevezésre gondolva itt).
Lehetséges több állomány egyidejű feltöltése is, az input elemek name paramétereinek különbözőre állításával.
Úgyszintén lehetőség van több megegyező nevű űrlap elemmel is több állomány feltöltésére. Ebben az esetben a kapcsolódó információkat tömbökben adja vissza a PHP. Ehhez a hagyományos tömbhivatkozást kell alkalmazni, mint minden más űrlapelemnél:
Megjegyzés: Több állomány egyidejű feltöltése a PHP 3.0.10 óta lehetséges.
Amikor a fenti űrlap adatai elküldésre kerülnek, a $_FILES['userfile'] $_FILES['userfile']['name'] és $_FILES['userfile']['size'] változók értéket kapnak. A $HTTP_POST_FILES tömbben ugyanezek elérhetőek a PHP 4.1.0 előtti verziókban. Ezek mind számokkal indexelt tömbök a tömbben beküldötteknek megfelelő értékekkel. A PHP 3-ban a $HTTP_POST_VARS használható. Ha a register_globals be van kapcsolva, globális változókat is létrehozásra kerülnek.
Páldául ha a /home/test/review.html és /home/test/xwp.out állományok kerültek feltöltésre, akkor a $_FILES['userfile']['name'][0] tartalma review.html és a $_FILES['userfile']['name'][1] tartalma xwp.out. Hasonló módon a $_FILES['userfile']['size'][0] a review.html fájl méretét tartalmazza, stb.
$_FILES['userfile']['name'][0], $_FILES['userfile']['tmp_name'][0], $_FILES['userfile']['size'][0] és $_FILES['userfile']['type'][0] szintén elérhetőek.
A PUT feltöltés támogatása a PHP 3 és a PHP 4 között megváltozott. PHP 4-ben a PUT-al küldött adatok a szabványos bemenetről olvasva gyűjthetőek be.
Példa 38-5. HTTP PUT által feltöltött állományok lementése PHP 4-ben
|
Megjegyzés: A további bekezdések csupán a PHP 3-ra vonatkoznak már.
A PHP támogatja a HTTP PUT metódust is, amit például a Netscape Composer és a W3C Amaya használ. A PUT kérések sokkal egyszerűbbek, mint az eddig tárgyalt feltöltések. A következőképpen néz ki:
Ez hagyományosan azt jelenti, hogy a kliens a küldött adatokat az /eleresi/ut/filenev.html fájlba szeretné elmenteni a webgyökér alatt. Az nyilvánvalóan nem lenne jó megoldás az Apache vagy a PHP részéről, ha bárkinek megengedné, hogy felülírja a fájlokat a web könyvtáradban. Éppen ezért a PUT kérések kezeléséhez be kell állítani a webszerver számára, hogy egy PHP szkriptnek küldje az ilyen bemenetet. Apache alatt ezt a Script direktívával teheted meg. Ez elhelyezhető szinte tetszőleges ponton az Apache konfigurációs fájlodban. Egy gyakori hely erre egy <Directory> blokk belseje, vagy esetleg egy <Virtualhost> blokk belseje. Például egy ilyen sor megoldja a feladatot:
Ez beállítja az Apache számára a PUT kérések kezelésére a put.php-t abban a környezetben, ahol ezt a sort elhelyezted a konfiguráláskor. Ez természetesen feltételezi, hogy a .php kiterjesztést a PHP kezeli és a PHP aktív.
A put.php fájlban aztán valami hasonlót tehetsz:
Ez a kérés által meghatározott helyre másolja a küldött fájlt. Valós helyzetben természetesen szükséges valamilyen ellenőrzés, és/vagy felhasználóazonosítás, mielőtt esetleg felülírod egyik fontos fájlodat. A PHP a POST metódushoz hasonlóan egy ideiglenes fájlban tárolja a feltöltött fájlt. Amikor a kérés teljesítése befejeződött, ez az ideiglenes fájl törlődik. Ez azt jelenti, hogy a PUT kéréseket feldolgozó szkriptednek ezt a fájlt el kell mozgatnia máshova, ha meg szeretnéd tartani a feltöltött fájlt. Az ideiglenesen létrehozott fájl elérési útját a fájl nevével a $PHP_PUT_FILENAME váltózó tartalmazza, és a javasolt célt a $REQUEST_URI változó tartalmazza (bár ez lehet más is nem Apache szervereken). Ez a cél az, amit a kliens meghatározott. Neked nem kell feltétlenül ezt a helyet elfogadnod, lehet, hogy neked az a kényelmesebb (és biztonságosabb), hogy a feltöltött fájlokat egy speciális upload könyvtárban tárolod.
Amennyiben az allow_url_fopen be van kapcsolva a php.ini-ben, HTTP és FTP URL-eket lehet paraméterként átadni majdnem minden olyan függvénynek, amelyek fájlnevet kér paraméterül, beleértve az include(), include_once(), require() és require_once() utasításokat is. További információkért a használható protokollokkal kapcsolatban nézz el ide: M Függelék.
Megjegyzés: PHP 4.0.3 és régebbi verziókban az ilyen URL-ek értelmezéséhez szükséges a --enable-url-fopen-wrapper beállítás bekapcsolása.
Megjegyzés: A Windows-os, 4.3 előtti változatok PHP nem támogatják a távoli állományelérést a következő függvények esetén: include(), include_once(), require() és require_once(), valamint az imagecreatefromXXX függvények esetén. Ezekről többet: LXII, Képmanipuláló függvények Referencia
Ezt a lehetőséget lehet használni például egy távoli webszerveren lévő fájlt megnyitására, majd a kívánt adatok kigyűjtésére, vagy arra, hogy csak egyszerűen a saját oldalad kinézetével, stílusával tálald.
Példa 39-1. Egy távoli weboldal címsorának megállapítása
|
Lehetőség van egy FTP szerveren tárolt fájlba írásra is, feltéve, hogy megfelelő jogokkal rendelkező user-ként lépsz be. Ezzel a módszerrel csak új fájlok hozhatók létre, ha már létezik a megadott nevű állomány akkor a fopen() hívása sikertelen lesz. Ha nem 'anonymous' felhasználóként szeretnél belépni, a felhasználói nevet és jelszót az URL részeként kell megadni a alábbi formában: 'ftp://felhasznalo:jelszo@ftp.pelda.hu/eleresi/ut/alma.txt'. (Ugyanezt a módszert használható akkor is, ha olyan állományokat kell elérni HTTP-n keresztül, amelyek a Basic azonosítást igénylik.)
Megjegyzés: A fenti példa alapján talán azt hihetnénk, hogy ilyen technikát kell használni például távoli naplózáshoz. Sajnálatos módon azonban ez nem működik, mert a fopen() hívása sikertelen lesz, ha a távoli állomány már létezik. Az ehhez hasonló elosztott, távoli naplózáshoz a syslog() függvény szolgáltatásait kell igénybe venni.
Megjegyzés: Az alábbi fejezetek csak a PHP 3.0.7-es és későbbi verzióira vonatkoznak!
A PHP futása közben nyilvántartja a kapcsolati státuszt. Három lehetséges állapot van:
0 - NORMAL (Normál)
1 - ABORTED (Megszakított)
2 - TIMEOUT (Időtúllépéses)
Amikor egy PHP szkript fut, alapállapotban a NORMAL állapot aktív. Ha a távoli kliens bontja a kapcsolatot, az ABORTED statátusz jelzése lesz aktív. Ez tipikusan akkor áll elő, ha a látogató a STOP gomb-ot használja a böngészőjében. Ha a PHP által felügyelt időkorált kerül túllépésre (lásd a set_time_limit() függvényt), a TIMEOUT állapot válik aktívvá.
Eldöntheted, hogy ha a kliens bontja a kapcsolatot, a szkript is leálljon-e vagy sem. Néha hasznos lehet, ha a szkriptjeid mindig végigfutnak, annak ellenére, hogy a kliens már nem fogadja a kimenetet. Alapbeállításban azonban a szkript is befejezi a futását, ha a kliens bontja a kapcsolatot. Ez a viselkedés az ignore_user_abort php.ini beállítással, valamint az ennek megfelelő "php_value ignore_user_abort" Apache .conf direktívával állítható, vagy az ignore_user_abort() függvénnyel. Ha nem konfigurálod úgy a PHP-t, hogy hagyja figyelmen kívül a kliens kapcsolatbontását, a szkriptjeid le fognak állni ilyen esetekben. Egyetlen kivétel ez alól, ha egy 'shutdown' függvényt definiálsz a register_shutdown_function()-al. Egy ilyen beállítással, ha a látogató lenyomja a STOP gombot, a szkripted következő kimenet-küldési kísérletére a PHP a 'shutdown' függvényt fogja meghívni. A 'shutdown' függvény abban az esetben is meghívásra kerül, ha a szkript normálisan befejezi a futását, tehát ha valami speciálisat szeretnél tenni, amikor a kliens bontja a kapcsolatot, a connection_aborted() függvényt használhatod. Ez igazat fog visszaadni, ha a kapcsolatot a kliens bontotta.
A szkripted a belső időmérés következtében is megállhat. Alapbeállításban egy szkript maximum 30 másodpercig futhat. Ez megváltoztatható a max_execution_time php.ini direktívával, illetve a megfelelő php_value max_execution_time Apache .conf beállítással, valamint a set_time_limit() függvénnyel. Amikor ez az idő letelik, a szkript megáll, és ha a fenti esetben említett 'shutdown' függvény definiált, az kerül meghívásra. Az időtúllépés esetét a connection_status() függvényel állapíthatod meg. Ez 2-es értéket fog visszaadni, ha időtúllépés miatt hívódott meg a 'shutdown'.
Fontos megjegyezni, hogy az ABORTED és TIMEOUT állapotok egyszerre is aktívak lehetnek, ha a PHP-ben a kliens kapcsolatbontásának figyelmen kívül hagyását kérted. A PHP tudni fogja, hogy a kliens már bontotta a kapcsolatot, de a szkript futni fog tovább. Ha ráadásul eléri az időkorlátot, a szkript megáll, és a 'shutdown' függvény hívódik meg (ha beállítottál ilyet). Ezen a ponton azt fogod tapasztalni, hogy a connection_status() függvény 3-as értékkel fog visszatérni.
Az állandó kapcsolatok olyan összeköttetések, melyek nem szűnnek meg, ha a szkripted futása befejeződik. Ha egy állandó kapcsolatot kérsz, a PHP ellenőrzi, hogy van-e már megegyező kapcsolat (ami még az előző kérésekből maradhatott meg), és ha létezik, akkor azt használja. Ha nem talál ilyet, létrehoz egy kapcsolatot. A megegyező kapcsolat azt jelenti, hogy ugyanaz a host és ugyanaz a felhasználói név és jelszó került felhasználásra.
Ha esetleg nem ismered alaposabban a webszerverek működését, hibás kép alakulhat ki benned az állandó kapcsolatokról. Ezek a kapcsolatok nem alkalmasak arra, hogy felhasználói 'session'-öket nyiss ugyanazon az összeköttetésen. Nem adnak lehetőséget hatékony tranzakciók felépítésére. Egészen pontosan, hogy alaposabban tisztázzuk a kérdést, az állandó adatbázis kapcsolatok nem adnak semmilyen plusz lehetőséget, ami nélkülük nem létezne.
Miért?
A válaszhoz meg kell érteni, hogyan működnek együtt a webszerverek a PHP-vel. Ennek három különböző módja lehetséges.
Az első lehetőség, hogy a PHP-t CGI "wrapper"-ként használod. Ha ezt a módszert használod, minden oldal lekérésekor és feldolgozásakor egy új példány fut le a PHP feldolgozóból. Mivel a szkript futtatása után egy ilyen példány leáll, minden erőforrás, amit lefoglalt (beleértve az adatbázis kapcsolatotokat) megszűnik. Ebben az esetben semmit sem érsz azzal, hogy állandó kapcsolatot próbálsz nyitni, ez az állandóság nem valósul meg.
A népszerűbb második forma, amikor a PHP-t modulként futtatod egy több process-es webszerverben. Egy több process-es webszerver tipikusan rendelkezik egy szülő process-el, ami koordinálja a többi kapcsolódó process (a gyermekek) munkáját, amik valójában a weboldalak kiszolgálását végzik. Ha egy kérés érkezik egy klienstől, egy éppen szabad gyermekprocess kapja meg a kiszolgálásra az utasítást. Ez azt jelenti, hogy ha ugyanaz a kliens egy újabb kapcsolatot kezdeményez, esetleg egy másik gyermekprocesshez jut, mint az első alkalommal. Amennyiben állandó kapcsolator nyitsz, egy későbbi oldal fel tudja használni ugyanezt a kapcsolatot.
A harmadik módszer, hogy a PHP-t plug-in-ként használod egy 'multithreaded' web szerverben. Ez azt jelenti, hogy az ISAPI, WSAPI, és NSAPI (Windows alatt) formák használhatóak a PHP-vel. Ez a PHP 4.0.0 óta lehetséges, és így a PHP alkalmas plug-in szintű együttműködésre a Netscape FastTrack (iPlanet), a Microsoft Internet Information Server (IIS), és az O'Reilly WebSite Pro szerverekkel, valamint más, a fenti standardokat támogató szerverekkel. Ebben az esetben az állandó adatbázis kapcsolatok működése megegyezik a fent leírt több process-es modellel.
Ha az állandó adatbázis kapcsolatok nem nyújtanak plusz szolgáltatásokat, mégis mire jók?
A válasz igen egyszerű: hatékonyság! Az állandó adatbázis kapcsolatok akkor lehetnek hasznosak, ha nagy a feleslegesen adatbázishoz kapcsolódással eltöltött idő. Az, hogy ez valójában milyen esetben van így, rengeteg faktoron múlik. Például azon, hogy milyen típusú adatbázisról van szó, azonos, vagy különböző gépen van-e, mint a szerver, mennyire terhelt az SQL szerver, stb. Lényegében, ha sok időt vesz igénybe a kapcsolódás, az állandó kapcsolatok jelentős segítséget nyújthatnak neked. Egy gyermekprocess így csak egy alkalommal kell, hogy kapcsolódjon, ahelyett, hogy egy ezt kérő oldal minden feldolgozásakor megtenné. Ez azt is jelenti, hogy minden gyermekprocessnek, meglesz a maga állandó kapcsolata a szerver felé. Például, ha 20 különböző gyermekprocess dolgozott fel egy állandó adatbáziskapcsolatot kérő oldalt, 20 különböző állandó kapcsolatod lesz az SQL szerverhez, egy-egy minden gyermektől.
Fontos megjegyezni azonban, hogy ennek lehetnek hátrányos következményei is, ha az adatbázisszerver korlátozott kapcsolatainak számát az állandó kapcsolatok lefoglalják. Ha az adatbázisszervered egyidejűleg maximálisan 16 kapcsolatot képes kezelni, és egy forgalmas időszakban egyszerre 17 process próbál meg kapcsolódni az adatbázishoz, az egyik képtelen lesz erre... Ha olyan hiba van a programodban (például végetelen ciklus), ami nem hagyja a kapcsolat felbontását, egy csak 16 kapcsolattal bíró adatbázis alaposan le lesz foglalva. Nézz utána az adatbázisszervered dokumentációjában, hogy hogyan tudod lekezelni az elhagyott vagy inaktív kapcsolatokat.
| Figyelem |
Van még néhány faktor, amit érdemes figyelembe venned, ha állandó adatbázis kapcsolatokat használsz. Egy ilyen probléma, hogy ha tábla lezárást (lock) használsz egy állandó kapcsolaton, és a szkript valamilyen okból nem tudja feloldani a zárat, ezt a kapcsolatot használó további szkriptek nem fognak helyesen működni, és a webszerver vagy adatbázis szerver újraindítására lehet szükség a feloldáshoz. Hasonlóan ha tranzakciókat használsz, a tranzakció blokk tovább folytatódik a következő megegyező kapcsolatot használó szkriptben, ha a tranzakciót indító szkript nem tudja lezárni azt. Ezekben az esetekben a register_shutdown_function() függvényt használhatod, hogy egy egyszerű "takarító" függvényt futtass le a programod végeztével, ami visszavonja a tranzakciókat, és feloldja a tábla zárakat. Jobban teszed azonban, ha úgy kerülöd meg a problémát, hogy nem használsz állandó kapcsolatokat olyan szkriptekben, amik tábla zárakat, vagy tranzakciókat alkalmaznak. |
Összefoglalva: az állandó adatbáziskapcsolatokat úgy tervezték, hogy megfeleltethetőek legyenek a hagyományos kapcsolatokkal. Ez azt jelenti, hogy minden esetben lehetőséged van az állandó kapcsolatokat hagyományos kapcsolatokra cserélni, és ez nem fogja megváltoztatni a szkriptjeid működését. Ez a lépés megváltoztathatja a szkripted hatékonyságát, de a viselkedését nem!
Lásd még fbsql_pconnect(), ibase_pconnect(), ifx_pconnect(), ingres_pconnect(), msql_pconnect(), mssql_pconnect(), mysql_pconnect(), ociplogon(), odbc_pconnect(), ora_plogon(), pfsockopen(), pg_pconnect(), és sybase_pconnect().
The PHP safe mode is an attempt to solve the shared-server security problem. It is architecturally incorrect to try to solve this problem at the PHP level, but since the alternatives at the web server and OS levels aren't very realistic, many people, especially ISP's, use safe mode for now.
| Figyelem |
Safe Mode was removed in PHP 6.0.0. |
Táblázat 42-1. Security and Safe Mode Configuration Directives
| Name | Default | Changeable | Changelog |
|---|---|---|---|
| safe_mode | "0" | PHP_INI_SYSTEM | |
| safe_mode_gid | "0" | PHP_INI_SYSTEM | Available since PHP 4.1.0. |
| safe_mode_include_dir | NULL | PHP_INI_SYSTEM | Available since PHP 4.1.0. |
| safe_mode_exec_dir | "" | PHP_INI_SYSTEM | |
| safe_mode_allowed_env_vars | "PHP_" | PHP_INI_SYSTEM | |
| safe_mode_protected_env_vars | "LD_LIBRARY_PATH" | PHP_INI_SYSTEM | |
| open_basedir | NULL | PHP_INI_SYSTEM | |
| disable_functions | "" | php.ini only | Available since PHP 4.0.1. |
| disable_classes | "" | php.ini only | Available since PHP 4.3.2. |
A témába vágó konfigurációs direktívák rövid leírása
Whether to enable PHP's safe mode.
By default, Safe Mode does a UID compare check when opening files. If you want to relax this to a GID compare, then turn on safe_mode_gid. Whether to use UID (FALSE) or GID (TRUE) checking upon file access.
UID/GID checks are bypassed when including files from this directory and its subdirectories (directory must also be in include_path or full path must including).
As of PHP 4.2.0, this directive can take a colon (semi-colon on Windows) separated path in a fashion similar to the include_path directive, rather than just a single directory.
The restriction specified is actually a prefix, not a directory name. This means that "safe_mode_include_dir = /dir/incl" also allows access to "/dir/include" and "/dir/incls" if they exist. When you want to restrict access to only the specified directory, end with a slash. For example: "safe_mode_include_dir = /dir/incl/"
If the value of this directive is empty, no files with different UID/GID can be included in PHP 4.2.3 and as of PHP 4.3.3. In earlier versions, all files could be included.
If PHP is used in safe mode, system() and the other functions executing system programs refuse to start programs that are not in this directory. You have to use / as directory separator on all environments including Windows.
Setting certain environment variables may be a potential security breach. This directive contains a comma-delimited list of prefixes. In Safe Mode, the user may only alter environment variables whose names begin with the prefixes supplied here. By default, users will only be able to set environment variables that begin with PHP_ (e.g. PHP_FOO=BAR).
Megjegyzés: If this directive is empty, PHP will let the user modify ANY environment variable!
This directive contains a comma-delimited list of environment variables that the end user won't be able to change using putenv(). These variables will be protected even if safe_mode_allowed_env_vars is set to allow to change them.
Limit the files that can be opened by PHP to the specified directory-tree, including the file itself. This directive is NOT affected by whether Safe Mode is turned On or Off.
When a script tries to open a file with, for example, fopen() or gzopen(), the location of the file is checked. When the file is outside the specified directory-tree, PHP will refuse to open it. All symbolic links are resolved, so it's not possible to avoid this restriction with a symlink.
The special value . indicates that the working directory of the script will be used as the base-directory. This is, however, a little dangerous as the working directory of the script can easily be changed with chdir().
In httpd.conf, open_basedir can be turned off (e.g. for some virtual hosts) the same way as any other configuration directive with "php_admin_value open_basedir none".
Under Windows, separate the directories with a semicolon. On all other systems, separate the directories with a colon. As an Apache module, open_basedir paths from parent directories are now automatically inherited.
The restriction specified with open_basedir is actually a prefix, not a directory name. This means that "open_basedir = /dir/incl" also allows access to "/dir/include" and "/dir/incls" if they exist. When you want to restrict access to only the specified directory, end with a slash. For example: "open_basedir = /dir/incl/"
Megjegyzés: Support for multiple directories was added in 3.0.7.
The default is to allow all files to be opened.
This directive allows you to disable certain functions for security reasons. It takes on a comma-delimited list of function names. disable_functions is not affected by Safe Mode.
This directive must be set in php.ini For example, you cannot set this in httpd.conf.
This directive allows you to disable certain classes for security reasons. It takes on a comma-delimited list of class names. disable_classes is not affected by Safe Mode.
This directive must be set in php.ini For example, you cannot set this in httpd.conf.
Availability note: This directive became available in PHP 4.3.2
See also: register_globals, display_errors, and log_errors.
When safe_mode is on, PHP checks to see if the owner of the current script matches the owner of the file to be operated on by a file function or its directory. For example:
-rw-rw-r-- 1 rasmus rasmus 33 Jul 1 19:20 script.php -rw-r--r-- 1 root root 1116 May 26 18:01 /etc/passwd |
<?php
readfile('/etc/passwd');
?> |
Warning: SAFE MODE Restriction in effect. The script whose uid is 500 is not allowed to access /etc/passwd owned by uid 0 in /docroot/script.php on line 2 |
However, there may be environments where a strict UID check is not appropriate and a relaxed GID check is sufficient. This is supported by means of the safe_mode_gid switch. Setting it to On performs the relaxed GID checking, setting it to Off (the default) performs UID checking.
If instead of safe_mode, you set an open_basedir directory then all file operations will be limited to files under the specified directory. For example (Apache httpd.conf example):
<Directory /docroot> php_admin_value open_basedir /docroot </Directory> |
Warning: open_basedir restriction in effect. File is in wrong directory in /docroot/script.php on line 2 |
You can also disable individual functions. Note that the disable_functions directive can not be used outside of the php.ini file which means that you cannot disable functions on a per-virtualhost or per-directory basis in your httpd.conf file. If we add this to our php.ini file:
disable_functions readfile,system |
Warning: readfile() has been disabled for security reasons in /docroot/script.php on line 2 |
| Figyelem |
These PHP restrictions are not valid in executed binaries, of course. |
This is a still probably incomplete and possibly incorrect listing of the functions limited by safe mode.
Táblázat 42-2. Safe mode limited functions
| Function | Limitations |
|---|---|
| dbmopen() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| dbase_open() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| filepro() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| filepro_rowcount() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| filepro_retrieve() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| ifx_* | sql_safe_mode restrictions, (!= safe mode) |
| ingres_* | sql_safe_mode restrictions, (!= safe mode) |
| mysql_* | sql_safe_mode restrictions, (!= safe mode) |
| pg_lo_import() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| posix_mkfifo() | Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| putenv() | Obeys the safe_mode_protected_env_vars and safe_mode_allowed_env_vars ini-directives. See also the documentation on putenv() |
| move_uploaded_file() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| chdir() | Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| dl() | Ez a függvény nem használható, ha a safe mode be van kapcsolva. |
| backtick operator | Ez a függvény nem használható, ha a safe mode be van kapcsolva. |
| shell_exec() (functional equivalent of backticks) | Ez a függvény nem használható, ha a safe mode be van kapcsolva. |
| exec() | You can only execute executables within the safe_mode_exec_dir. For practical reasons it's currently not allowed to have .. components in the path to the executable. escapeshellcmd() is executed on the argument of this function. |
| system() | You can only execute executables within the safe_mode_exec_dir. For practical reasons it's currently not allowed to have .. components in the path to the executable. escapeshellcmd() is executed on the argument of this function. |
| passthru() | You can only execute executables within the safe_mode_exec_dir. For practical reasons it's currently not allowed to have .. components in the path to the executable. escapeshellcmd() is executed on the argument of this function. |
| popen() | You can only execute executables within the safe_mode_exec_dir. For practical reasons it's currently not allowed to have .. components in the path to the executable. escapeshellcmd() is executed on the argument of this function. |
| fopen() | Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| mkdir() | Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| rmdir() | Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| rename() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| unlink() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| copy() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. (on source and target) |
| chgrp() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| chown() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. |
| chmod() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. In addition, you cannot set the SUID, SGID and sticky bits |
| touch() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. |
| symlink() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. (note: only the target is checked) |
| link() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. (note: only the target is checked) |
| apache_request_headers() | In safe mode, headers beginning with 'authorization' (case-insensitive) will not be returned. |
| header() | In safe mode, the uid of the script is added to the realm part of the WWW-Authenticate header if you set this header (used for HTTP Authentication). |
| PHP_AUTH variables | In safe mode, the variables PHP_AUTH_USER, PHP_AUTH_PW, and AUTH_TYPE are not available in $_SERVER. Regardless, you can still use REMOTE_USER for the USER. (note: only affected since PHP 4.3.0) |
| highlight_file(), show_source() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. (note: only affected since PHP 4.2.1) |
| parse_ini_file() | Ellenőrzi, hogy az állományok/könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program. Ellenőrzi, hogy a könyvtár, amelyben dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkezik-e, mint az éppen futó program. (note: only affected since PHP 4.2.1) |
| set_time_limit() | Has no effect when PHP is running in safe mode. |
| max_execution_time | Has no effect when PHP is running in safe mode. |
| mail() | In safe mode, the fifth parameter is disabled. (note: only affected since PHP 4.2.3) |
| Any function that uses php4/main/fopen_wrappers.c | ?? |
A 4.3-as verziótól felfelé a PHP támogat egy új SAPI (Server Application Programming Interface) típust, a CLI-t ami a Command Line Interface rövidítése. A nevéből következik, hogy ez a SAPI típus leginkább shell (vagy akár desktop!) alkalmazások fejlesztéséhez használatos a PHP-ben. Van néhány különbség a CLI SAPI és a többi SAPI között, ezek magyarázatára a későbbiekben rátérünk. Nem árt megjegyezni, hogy a CLI és a CGI két különböző SAPI bár elég hasonló a viselkedésmódjuk.
A CLI SAPI először a PHP 4.2.0 verziójában jelent meg, de akkor még csak kísérleti jelleggel. Használatához a --enable-cli kapcsolóval kellett indítani a ./configure scriptet installáláskor. A PHP 4.3.0 megjelenésétől megszűnt a CLI SAPI kísérleti státusza és a --enable-cli alapértelmezésben be van állítva. Kikapcsolásához a --disable-cli konfigurációs paramétert használhatod.
A PHP 4.3.0-tól a CLI/CGI binárisok neve, helye és létezése függ attól, hogyan lett a PHP telepítve. Alapértelmezésben, a make parancs végrehajtásakor, a CGI és a CLI is létre lesz hozva és a sapi/cgi/php illetve a sapi/cli/php könytárakba lesznek helyezve a PHP forráskönyvtáron belül. Észreveheted, hogy mindkettőnek a neve php. Ami a make install folyamán történik, az a configure opcióktól függ. Ha ki lett választva egy SAPI modul, mint pl. aspx, vagy a --disable-cgi meg volt adva, akkor a make install idejére a {PREFIX}/bin/php helyen a CLI lesz, egyébként pedig a CGI-t teszi oda. Például ha --with--apxs benne van a configure sorban, akkor a CLI-t másolja a {PREFIX}/bin/php helyre a make install idejére. Ha felül akarod bírálni a CGI bináris telepítését, akkor a make install után add ki a make install-cli parancsot. Egy másik lehetőség, hogy megadod a --disable-cgi configure opciót.
Megjegyzés: Mivel mind a --enable-cli mind a --enable-cgi alapértelmezésben be van állítva, az, hogy a configure sorban az --enable-cli meg van adva, nem feltétlenül jelenti azt, hogy a CLI lesz a {PREFIX}/bin/php helyre másolva a make install idejére.
A PHP 4.2.0 és PHP 4.2.3 közötti windows-os csomagok a CLI-t php-cli.exe-ként tartalmazták ugyanabban a könyvtárban, mint a CGI php.exe. A PHP 4.3.0-tól kezdődően a windows-os csomag a CLI-t php.exe-ként tartalmazza egy cli nevű könyvtárban, azaz cli/php.exe. A PHP 5-től kezdődően a CLI a főkönyvtárban van és a neve php.exe. A CGI verzió a php-cgi.exe.
A PHP 5-től egy új php-win.exe nevű fájl is található a csomagban. Ez csak annyiban különbözik a CLI verziótól, hogy a kimenetre nem ír ki semmit, így nem jelenít meg konzolt (nem jelenik meg a dos ablak a képernyőn). Ez a viselkedésmód hasonló a php-gtk-éhoz. A configure opciók között az --enable-cli-win32 kell szerepeljen.
Milyen SAPI-m van?: Egy shell-be beírva a php -v elárulja hogy a php CGI vagy CLI. Lásd még a php_sapi_name() függvényt valamint a PHP_SAPI konstanst.
Megjegyzés: A PHP 4.3.2-től egy létrejött egy unix man oldal. Ezt a man php shell-be beírt paranccsal nézheted meg.
Lényegesebb különbségek a CLI SAPI és a többi SAPI között:
A CGI SAPI-val ellentétben soha nem ír ki fejléceket.
Habár a CGI SAPI lehetőséget ad a HTTP fejlécek letiltására egy kapcsolóval, de ez nem egyenértékű a CLI SAPI által nyújtott megoldással.
A CLI alapértelmezetten "csendes" (quiet) módban indul, bár a -q és a --no-header kapcsolót megtartották a kompatibilitás érdekében, hogy régebbi CGI szkripteket is problémamentesen lehessen futtatni.
Nem cseréli fel az aktuális könyvtárat az éppen futó szkript könyvtárára. (A -C és a --no-chdir kapcsolót azért megtartották a kompatibilitás érdekében)
Egyszerű, szöveges hibaüzenetek (nincs HTML formázás).
Vannak php.ini utasítások, melyeket a CLI SAPI egyszerűen figyelmen kívül hagy, mivel nincs közük a shell környezethez:
Táblázat 43-1. Figyelmen kívül hagyott php.ini utasítások
| Utasítás | CLI SAPI default value | Magyarázat |
|---|---|---|
| html_errors | FALSE | A shellben lehetetlen elolvasni a hibaüzeneteket, ha azok zavaros HTML elemekkel tarkítva száguldanak át a képernyőn. Emiatt ez az utasítás alapértelmezetten FALSE. |
| implicit_flush | TRUE | Általában azt akarjuk, hogy a print(), echo() és a hasonszőrű függvények mindenképpen írjanak a kimenetre és ne puffereljenek semmit. De használható a output buffering utasítás, ha a kimenet késleltetése vagy manipulálása a cél. |
| max_execution_time | 0 (korlátlan) | Minden eshetőségre felkészülve a PHP nem korlátozza a shell szkriptek futásidejét. Ez érthető, hiszen míg egy webes szkript általában nagyon gyorsan lefut, addig a shellprogramok nagyon hosszú ideig futhatnak. |
| register_argc_argv | TRUE |
Mivel ez a beállítás TRUE, CLI SAPI-ban mindig rendelkezésedre állnak az argc (az alkalmazásnak átadott argumentumok száma) és az argv (az aktuális argumentumok tömbje) változók. A PHP 4.3.0-tól a $argc és a $argv PHP változók CLI SAPI használata esetén létrejönnek és feltöltődnek a megfelelő értékekkel. Azelőtt ezen változók létrehozása ugyanúgy működött mint a CGI és MODUL verziókban, ahol a register_globals be kellett legyenek kapcsolva. A $_SERVER vagy a $HTTP_SERVER_VARS tömböt mindig használhatod függetlenül a verziótól és a register_globals beállítástól. |
Megjegyzés: Ezek az utasítások nem adhatók meg a fentiektől különböző értékekkel a konfigurációs php.ini fájlban vagy egyéb saját php.ini-ben (ismert, hogy több php.ini is használható, akár könyvtáranként más). Ez egy korlátozás, mert alapértelmezett értékeik azután aktiválódnak, miután a konfigurációs fájlok lefutottak. Azonban ezek az értékek változhatnak a szkript futása alatt (ami nincs hatással minden említett utasításra, pl. register_argc_argv).
Hogy kényelmesebbé tegyék a parancssori programozást, néhány konstanst előre definiáltak:
Táblázat 43-2. Specifikus CLI konstansok
| konstansok | Leírás | ||
|---|---|---|---|
| STDIN |
Egy, már megnyitott stream (folyam) a stdin-re
(standard input - bemenet). A stream következőképpen történő
megnyitásától a megkímél bennünket:
| ||
| STDOUT |
Egy, már megnyitott stream az stdout-ra
(standard output - kimenet). A stream következőképpen történő
megnyitásától a megkímél bennünket:
| ||
| STDERR |
Egy, már megnyitott stream az stderr-re (ez
a hibaüzenetek kiíratásáért felelős). A stream következőképpen történő
megnyitásától a megkímél bennünket:
|
A fentieknek megfelelően nincs szükség arra, hogy pl. megnyiss egy streamet az stderr-ért, hanem egyszerűen csak használd a konstanst a stream forrás helyett:
php -r 'fwrite(STDERR, "stderr\n");' |
A CLI SAPI nem cseréli az aktuális könyvtára a futó szkript könyvtárára!
Szemléletes példa erre a CGI SAPI sajátosságra:
<?php // Ez a mi kis tesztprogramunk amelynek neve: test.php echo getcwd(), "\n"; ?> |
A CGI verzió használatakor a következőkre számíthatunk:
$ pwd //Linux/Unix alatt kiírja az aktuális könyvtárat /tmp //az aktuális könyvtár a /tmp $ php -q másik_könyvtár/test.php /tmp/másik_könyvtár |
Ugyanez a CLI SAPI-val:
$ pwd /tmp $ php -f másik_könyvtár/test.php /tmp |
Megjegyzés: A fenti példában a CGI SAPI ugyanúgy viselkedik, mint a CLI SAPI, ha a -C kapcsolóval indítod a szkriptet a parancssorból.
Az alábbi listát a parancssori opciókról a PHP generálta. Ezt bármikor kilistáztathatod ha a PHP-t a -h kapcsolóval indítod parancssorból:
Usage: php [options] [-f] <file> [--] [args...]
php [options] -r <code> [--] [args...]
php [options] [-B <begin_code>] -R <code> [-E <end_code>] [--] [args...]
php [options] [-B <begin_code>] -F <file> [-E <end_code>] [--] [args...]
php [options] -- [args...]
-a Run interactively
-c <path>|<file> Look for php.ini file in this directory
-n No php.ini file will be used
-d foo[=bar] Define INI entry foo with value 'bar'
-e Generate extended information for debugger/profiler
-f <file> Parse <file>.
-h This help
-i PHP information
-l Syntax check only (lint)
-m Show compiled in modules
-r <code> Run PHP <code> without using script tags <?..?>
-B <begin_code> Run PHP <begin_code> before processing input lines
-R <code> Run PHP <code> for every input line
-F <file> Parse and execute <file> for every input line
-E <end_code> Run PHP <end_code> after processing all input lines
-H Hide any passed arguments from external tools.
-s Display colour syntax highlighted source.
-v Version number
-w Display source with stripped comments and whitespace.
-z <file> Load Zend extension <file>.
args... Arguments passed to script. Use -- args when first argument
starts with - or script is read from stdin |
A CLI SAPI-val háromféleképpen indíthatsz el egy PHP programot:
Hogyan lehet a PHP-vel fájlokat futtatni.
php my_script.php php -f my_script.php |
PHP kód futtatása közvetlenül a parancssorból.
php -r 'print_r(get_defined_constants());' |
Megjegyzés: A példát figyelmesen szemlélve észrevehetjük, hogy nincsenek nyitó és záró tagok. Az -r kapcsolóval ezekre nincs szükség. Ha mégis használod őket, az hibához fog vezetni.
PHP kód futtatása a standard inputon (stdin) keresztül.
Ez a módszer dinamikussá teszi a PHP kód létrehozását és egyből a futtatható binárisba táplálja a kódot, amint a következő (képzeletbeli) példában láthatjuk:
$ valami_szkript | valami_filter | php | sort -u >eredmeny.txt |
Mint minden shellprogram, a PHP bináris képes argumentumokat fogadni, viszont az általad írt PHP szkript is. Bármennyi argumentumot megadhatsz a szkriptednek, ezek számát nem korlátozza a PHP (A shellben van egy bizonyos határ a megadható argumentumok számát illetően, de az általában bőségesen elég). A szkriptnek átadott argumentumokat a $argv globális tömb tartalmazza. A tömb nulladik eleme mindig a szkript neve. (Ez a - karakterjel abban az esetben, ha a PHP kód az -r kapcsolóval lett indítva a parancssorból.) A másik globális tömb a $argc, ami a $argv tömb elemeinek számát tartalmazza (de ez nem egyenlő a szkriptnek átadott argumentumok számával).
Amikor különféle opciókkal akarod futtatni egy szkriptet, az argumentumoknak nem szabad - karakterrel kezdődniük. Ha mégis kiteszed a - jelet, akkor abból könnyen probléma lehet, mert a PHP úgy veszi, mintha a saját opciói közül adnál meg egyet. Hogy ezt elkerüld, használd a -- szeparátort, és az utána következő az argumentumokat a PHP változtatás nélkül továbbítja a szkriptnek.
# Ez nem fogja futtatni a megadott kódot, csak szemléltetésre jó.
$ php -r 'var_dump($argv);' -h
Usage: php [options] [-f] <file> [args...]
[...]
# Ez átadja a szkriptnek a '-h' argumentumot és megakadályozza a PHP-t abban,
# hogy a sajátjának higgye.
$ php -r 'var_dump($argv);' -- -h
array(2) {
[0]=>
string(1) "-"
[1]=>
string(2) "-h"
} |
Azonban van egy másik módja a PHP paracssori futtatásának. Lehet írni olyan programokat, melyek a #!/usr/bin/php sorral kezdődnek és ezt követi a "normál" PHP kód, a szabványos PHP kezdő-és záró tagokkal. Ha megfelelően beállítottad a fájl futtatási jogosultságát (pl. chmod +x test), úgy futtathatod a programodat, mint egy normál shell vagy perl szkriptet:
#!/usr/bin/php <?php var_dump($argv); ?> |
$ chmod +x test
$ ./test -h -- foo
array(4) {
[0]=>
string(6) "./test"
[1]=>
string(2) "-h"
[2]=>
string(2) "--"
[3]=>
string(3) "foo"
} |
A hosszú opciók a PHP 4.3.3-tól léteznek.
Táblázat 43-3. Parancssori opciók
| Opció | Hosszú opció | Leírás | |||
|---|---|---|---|---|---|
| -a | --interactive |
A PHP-t interaktív módban futtatja. | |||
| -c | --php-ini |
Ha nem a megszokott helyén van, akkor megadhatjuk ezzel a kapcsolóval, hogy hol a php.ini vagy megadhatunk egy saját INI fájlot (aminek nem muszáj php.ini nevet adni!), pl..:
| |||
| -n | --no-php-ini |
A php.ini teljes figyelmen kívül hagyása. Ez a kapcsoló a PHP 4.3.0 óta létezik. | |||
| -d | --define |
Ezzel az opcióval bármilyen konfigurációs utasítást, ami csak a php.ini-ben megtalálható, egy saját értékkel érvényesíthetünk a szkript futásának idejére. Az általános formája a következő:
Példák (a sorok az olvashatóság érdekében vannak tördelve):
| |||
| -e | --profile-info |
Aktiválja a részletes információs módot, amelyet a debugger/profiler használ. | |||
| -f | --file |
Értelmezi és futtatja az -f kapcsoló után megadott fájlot. Ez a kapcsoló opcionális és el lehet hagyni, pusztán a fájlnév elegendő a fájl futtatásához. | |||
| -h és -? | --help és --usage | Ezzel az opcióval lehet információt szerezni az aktuális parancssori opciókról és néhány sornyi magyarázatot hozzájuk. | |||
| -i | --info | Ez a parancsori opció meghívja a phpinfo() függvényt és kiírja az eredményét. Ha a PHP rosszul működik, ajánlatos kiadni egy php -i parancsot és figyelmesen elolvasni a hibaüzeneteket a táblázatokban. Készülj fel rá, hogy ha a CGI módot használod, akkor a kimenet HTML formázott, így a parancssorban szinte olvashatatlan. (Irányítsd át a kimenetet egy HTML fájlba (php -i >phpinfo.html) és nézd meg egy böngészővel.) | |||
| -l | --syntax-check |
Segítségével kényelmesen elvégezhető a szintaktikai ellenőrzés egy megadott PHP kódon. Ha nincs hiba, a standard kimenetre kiírja, hogy No syntax errors detected in <filename> És a shell visszatérési értéke 0. Hiba esetén a szöveg Errors parsing <filename>, majd kiírja a standard kimenetre a megérdemelt hibaüzenetet és a shell visszatérési értéke 255 lesz. Ez az opció nem jelzi a végzetes hibákat (mint pl. egy definiálatlan függvény). Használd ezt az -f kapcsolóval együtt, ha végzetes hibákat is akarsz találni. ;)
| |||
| -m | --modules |
Eme opció használatával a PHP kilistázza a beépített (és betöltött) PHP és Zend modulokat:
| |||
| -r | --run |
Ez az opció teszi lehetővé, hogy PHP parancsokat adjunk ki közvetlenül a parancssorból. A kezdő és a záró PHP tagok (<?php és ?>) nem kellenek és szintaktikai hibához fog vezetni, ha mégis alkalmazod őket.
| |||
| -B | --process-begin |
Az stdin feldolgozása előtt végrehajtandó PHP kód. PHP 5-től létezik. | |||
| -R | --process-code |
Minden bemeneti sorra végrehajtandó PHP kód. PHP 5-től létezik. Van két speciális változó, amely ebben a módban használható: $argn és $argi. Az $argn azt a sort tartalmazza, amelyet a PHP éppen feldolgoz, az $argi pedig a sornak a sorszámát tartalmazza. | |||
| -F | --process-file |
Minden bemeneti sorra végrehajtandó PHP fájl. PHP 5-től létezik. | |||
| -E | --process-end |
Minden bemeneti sor feldolgozása után végrehajtandó PHP kód. PHP 5-től létezik. Példa a -B, -R és -E opciók használatára: egy projekt sorainak megszámolása.
| |||
| -s | --syntax-highlight és --syntax-highlighting |
Színesben kiemelt forrását írja ki a szkriptnek. Ez az opció egy saját algoritmust használ a fájl elemzéséhez, amivel HTML kódot generál a forrásból a standard kimenetre. Ez a kód tartalmazza a színes kiemeléshez szükséges és az egyéb formázó tag-eket, a szabványos <code> [...] </code> HTML formában, de nem tartalmazza a HTML fejléceket.
| |||
| -v | --version |
Kiírja a PHP, PHP SAPI, és a Zend verziószámát a standard kimenetre, pl:
| |||
| -w | --strip |
Kommentek és felesleges sorközök nélkül listázza ki a kódot.
| |||
| -z | --zend-extension |
Betölti a Zend bővítményt. Ha csak a futtatandó szkript nevét adtuk meg utána, akkor a PHP megpróbálja ezt a bővítményt a rendszereden alapértelmezett függvéykönyvtár (library) útvonal alapján betölteni (Ez általában az /etc/ld.so.conf fájlban van definiálva a Linux rendszereken). Ha megadsz egy konkrét útvonalat, akkor a PHP ezt veszi alapul, nem pedig a rendszer általit. Relatív útvonalat is megadhatsz a PHP-nek, hogy az aktuális könyvtárhoz képest hol keresse a bővítményt. |
A PHP futtatható állomány segítségével PHP szkripteket webszervertől függetlenül lehet futtatni. Ha egy Unix rendszeren vagy, a PHP szkripted elejére egy speciális sort kell beillesztened, majd az állományt futtathatóvá kell tenned, így a rendszer tudni fogja melyik programmal kell futtatni a szkriptet. Windows-on a .php állományokhoz hozzárendelheted a php.exe programot, vagy készíthetsz egy batch fájlt, amellyel a szkriptet PHP-n keresztül tudod futtatni. A Unix rendszerek miatt beszúrt első sor nem fog problémát okozni Windows-on, így írhatsz platformfüggetlen programot is. Alább található egy példa parancssor PHP program írására.
Példa 43-1. Parancssorból futtatható szkript (script.php)
|
A fenti szkriptben használtuk a speciális első sort, hogy ezt a fájlt a PHP futtassa. Most a CLI verziót használjuk, így nem lesznek HTTP fejlécek kiírva. Van két változó, amit használhatsz parancssori PHP alkalmazások írásakor: $argc and $argv. Az első megadja az argumentumok számát + 1 (a futó szkript nevét). A második egy tömb, amely az argumentumokat tartalmazza, a szkript nevével kezdődően 0-tól számozva ($argv[0]).
A fenti programban megvizsgáljuk, hogy több vagy kevesebb mint egy argumentum van-e megadva. Ekkor vagy ha az argumentum --help, -help, -h vagy -?, akkor kiíratjuk a súgó üzenetet, a szkriptnevet dinamikusan írjuk ki. Ha más argumentumot kapunk, akkor azt kiírjuk.
Ha a fenti szkriptet Unix-on szeretnéd futtatni, futtathatóvá kell tenned, majd egyszerűen meghívhatod mint például script.php echothis vagy script.php -h. Windows-on készíthetsz egy batch fájlt erre a célra:
Feltételezve, hogy a fenti programot script.php-nek nevezted el, és a php.exe CLI programod a c:\php\cli\php.exe helyen van, ez a batch fájl lefutattja neked a további opciókkal: script.bat echothis vagy script.bat -h.
Lásd még a Readline kiterjesztés dokumentációját, ahol további függvényeket találsz a parancssori PHP alkalmazásaid fejlesztéséhez.
See also I Függelék.
| Figyelem |
Ez a kiterjesztés KÍSÉRLETI JELLEGGEL MŰKÖDIK. Ez azt jelenti, hogy minden itt dokumentált működés, beleértve a függvények nevét, működését vagy bármi más, amit a kiterjesztés kapcsán leírtunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a kiterjesztést csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
(PHP 4 >= 4.0.5, PHP 5)
apache_child_terminate -- Felszámolja az épp felhasznált Apache processzt a kérés utánAz apache_child_terminate() feljegyzi megszüntetésre az aktuális PHP kérést futtató Apache processzt, azaz miután a PHP szkript futása befejeződött, az Apache megkísérli ezt a processzt bezárni. Ezt pl. sok memóriát fogyasztó processzek leállításra lehet használni, mivel ez memória csak belsőleg szabadul fel általában, és az operációs rendszer szintjén nem jelenik meg.
Akkor tér vissza TRUE értékkel, ha a PHP Apache 1 modulként fut, valamint a child_terminate PHP konfigurációs direktíva engedélyezve van (alapértelmezésben tiltott). Ha a fenti feltételek nem teljesülnek, FALSE lesz a visszatérési érték, valamint egy E_WARNING szintű hibajelzés is létrejön.
Get an Apache environment variable as specified by variable.
This function requires Apache 2 otherwise it's undefined.
The Apache environment variable
Whether to get the top-level variable available to all Apache layers.
(PHP 3 >= 3.0.4, PHP 4, PHP 5)
apache_lookup_uri -- Végrehajt egy részleges kérést a meghatározott URI-re és visszatér ennek összes információjávalVégrehajt egy részleges kérést a meghatározott URI-re és visszatér ennek összes információjával. Elég messze elmegy ahhoz, hogy megszerezze az összes információt az adott forrásról és visszaadja ezeket egy osztályban. A visszaadott osztály tulajdonságai:
| status |
| the_request |
| status_line |
| method |
| content_type |
| handler |
| uri |
| filename |
| path_info |
| args |
| boundary |
| no_cache |
| no_local_copy |
| allowed |
| send_bodyct |
| bytes_sent |
| byterange |
| clength |
| unparsed_uri |
| mtime |
| request_time |
Példa 1. apache_lookup_uri() példa
A fenti példa valami ilyesmi kimenetet ad: A fenti példa az alábbi kimenetet hozza létre:
|
Megjegyzés: Az apache_lookup_uri() csak akkor működik, ha a PHP Apache modulként van telepítve.
Az apache_note() egy Apache-specifikus függvény amely egy kérésben értékeket kér le és állít be a notes táblában. Ha egy argumentummal hívod, akkor az aktuális note_name megjegyzés értékével tér vissza. Ha két argumentummal hívod, akkor beállítja a note_name értékét note_value-ra, és a note_name korábbi értékével tér vissza.
apache_request_headers() függvény az aktuális kérés összes HTTP fejlécével tér vissza, amit asszociatív tömbben ad vissza. Ez csak akkor használható, ha a PHP Apache modulként fut.
Példa 1. apache_request_headers() példa
A fenti példa valami ilyesmi kimenetet ad:
|
Megjegyzés: PHP 4.3.0-t megelőzően az apache_request_headers() neve getallheaders() volt. PHP 4.3.0-tól kezdve a getallheaders() csak álnévként szolgál a apache_request_headers() függvényhez.
Megjegyzés: A környezetből olvasva is lekérhetőek a tipikus CGI változók, és e módszer mindenképpen működik, függetlenül attól, hogy a PHP Apache modulként működik vagy sem. A phpinfo() használatával meg lehet tekinteni az ezen a módon definiált környezeti változók listáját.
Megjegyzés: A PHP 4.3.3 változatától kezdve ezt a függvényt használhatod a NSAPI szerver modullal a Netscape/iPlanet/SunONE rendszeren futó webszervereken is.
Lásd még: apache_response_headers()!
apache_reset_timeout() resets the Apache write timer, which defaults to 300 seconds. With set_time_limit(0); ignore_user_abort(true) and periodic apache_reset_timeout() calls, Apache can theoretically run forever.
This function requires Apache 1.
apache_response_headers() visszaadja az összes HTTP válasz-fejlécet.
Megjegyzés: A PHP 4.3.3 változatától kezdve ezt a függvényt használhatod a NSAPI szerver modullal a Netscape/iPlanet/SunONE rendszeren futó webszervereken is.
Lásd még: apache_request_headers() és headers_sent()!
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
Az ascii2ebcdic() egy Apache-specifikus függvény, és csak EBCDIC alapú operációs rendszereken érhető el (OS/390, BS2000). Egy ASCII kódolt ascii_str szöveget alakít át az annak megfelelő EBCDIC reprezentációvá (binary safe módon). Visszatérési értéke az eredmény.
Lásd még az ellentétes funkciót betöltő ebcdic2ascii() függvényt.
Az ebcdic2ascii() egy Apache-specifikus függvény, és csak EBCDIC alapú operációs rendszereken érhető el (OS/390, BS2000). Egy EBCDIC kódolt ebcdic_str szöveget alakít át az annak megfelelő ASCII reprezentációvá (binary safe módon). Visszatérési értéke az eredmény.
Lásd még az ellentétes funkciót betöltő ascii2ebcdic() függvényt.
getallheaders() a apache_request_headers() függvény álneve. Ez a függvény az aktuális HTTP kérés összes fejlécét visszadja egy asszociatív tömbben. Bővebb információért olvasd el a apache_request_headers() dokumentációját!
Megjegyzés: PHP 4.3.0-ban a getallheaders() csak a apache_request_headers() álneveként funkcionál tovább. Valójában a függvény nevét megváltoztatták, mivel csak akkor működik, ha a PHP Apache modulként fut.
Megjegyzés: A PHP 4.3.3 változatától kezdve ezt a függvényt használhatod a NSAPI szerver modullal a Netscape/iPlanet/SunONE rendszeren futó webszervereken is.
Lásd még apache_request_headers()!
A virtual() egy Apache-specifikus függvény, amely megegyezik a mod_include <!--#include virtual...--> megoldásával. Végrehajt egy Apache alkérést. Ez hasznos CGI szkriptek vagy .shtml fájlok beillesztésénél, vagy bármi másnál, amit egyébként az Apache dolgozott volna fel. Fontos a CGI szkripteknél, hogy a szkript érvényes CGI fejléceket generáljon. Ezt azt jelenti, hogy minimálisan egy Content-type fejlécet kell ki kell adnia.
Az alkérés futtatásához minden puffert le kell zárni és kiűríteni a tartalmát a kliens böngésző felé, és ezzel együtt minden függőben lévő fejléc is kiküldésre kerül.
| Figyelem |
Ez a függvény csak abban az esetben fog működni, ha Apache modulként működik a PHP-d, mivel annak API-ját használja az al-lekérések kivitelezéséhez. Teljes, adatokkal telitűzdelt GET hivatkozást adhatsz itt meg, de ezt csak a futtatandó script $_SERVER['QUERY_STRING'] változója fogja tükrözni. A hívó $_GET tömbjét fogja átvenni a meghívott PHP program. A QUERY_STRING átadása csak az Apache 2 használata esetén történik meg. A meghívott fájl az acces_log-ban nem fog nyomot hagyni. |
A PHP 4.0.6-os változatától felfele használható a virtual() PHP fájlokra is. Persze ettől függetlenül okosabb az include() vagy require() függvényeket használni erre a célra.
The Alternative PHP Cache (APC) is a free and open opcode cache for PHP. It was conceived of to provide a free, open, and robust framework for caching and optimizing PHP intermediate code.
Ez a PECL kiterjesztés a PHP alapterjesztésében nem szerepel.
További információk, mint például új kiadások, letöltés, forrásállományok, karbantartók, CHANGELOG találhatóak itt: http://pecl.php.net/package/apc.
Ezen PECL kiterjesztés DLL állományát letöltheted a PHP Letöltések, vagy a http://snaps.php.net/ címről.
Megjegyzés: On Windows, APC needs a temp path to exist, and be writable by the web server. It checks TMP, TEMP, USERPROFILE environment variables in that order and finally tries the WINDOWS directory if none of those are set.
Megjegyzés: For more in-depth, highly technical implementation details, see the developer-supplied TECHNOTES file .
Az alábbi függvények viselkedése befolyásolható a php.ini segítségével.
Although the default APC settings are fine for many installations, serious users should consider tuning the following parameters.
There are two main decisions you have to make. First, how much shared memory do you want to set aside for APC, and second, whether you want APC to check if a file has been modified on every request. The two ini directives involved here are apc.shm_size and apc.stat. Read the sections on these two directives carefully below.
Once you have a running server, you should copy the apc.php script that comes with the extension to somewhere in your docroot and load it up in your browser. It provides you with a detailed look at what is happening in your cache. If you have GD enabled in PHP, it will even have pretty graphs. First thing to check is of course that it is actually caching files. Assuming it is working you should then pay close attention to the Cache full count number on the left. That tells you the number of times the cache has filled up and has had to forcefully clean up any entries not accessed within the last apc.ttl seconds. You should configure your cache to minimize this number. If you are constantly filling your cache, the resulting cache churn is going to hurt performance. You should either set more memory aside for APC, or use apc.filters to cache fewer scripts.
Táblázat 1. APC configuration options
| Name | Default | Changeable | Changelog |
|---|---|---|---|
| apc.enabled | "1" | PHP_INI_ALL | |
| apc.shm_segments | "1" | PHP_INI_SYSTEM | |
| apc.shm_size | "30" | PHP_INI_SYSTEM | |
| apc.optimization | "0" | PHP_INI_ALL | |
| apc.num_files_hint | "1000" | PHP_INI_SYSTEM | |
| apc.ttl | "0" | PHP_INI_SYSTEM | |
| apc.gc_ttl | "3600" | PHP_INI_SYSTEM | |
| apc.cache_by_default | "1" | PHP_INI_SYSTEM | |
| apc.filters | NULL | PHP_INI_SYSTEM | |
| apc.mmap_file_mask | NULL | PHP_INI_SYSTEM | |
| apc.slam_defense | "0" | PHP_INI_SYSTEM | |
| apc.file_update_protection | "2" | PHP_INI_SYSTEM | |
| apc.enable_cli | "0" | PHP_INI_SYSTEM | > APC 3.0.6 |
| apc.max_file_size | "1M" | PHP_INI_SYSTEM | > APC 3.0.6 |
| apc.stat | "1" | PHP_INI_SYSTEM | > APC 3.0.9 |
A témába vágó konfigurációs direktívák rövid leírása
apc.enabled can be set to 0 to disable APC. This is primarily useful when APC is statically compiled into PHP, since there is no other way to disable it (when compiled as a DSO, the extension line in php.ini can just be commented-out).
The number of shared memory segments to allocate for the compiler cache. If APC is running out of shared memory but you have already set apc.shm_size as high as your system allows, you can try raising this value.
The size of each shared memory segment in MB. By default, some systems (including most BSD variants) have very low limits on the size of a shared memory segment.
The optimization level. Zero disables the optimizer, and higher values use more aggressive optimizations. Expect very modest speed improvements. This is experimental.
A "hint" about the number of distinct source files that will be included or requested on your web server. Set to zero or omit if you're not sure; this setting is mainly useful for sites that have many thousands of source files.
The number of seconds a cache entry is allowed to idle in a slot in case this cache entry slot is needed by another entry. Leaving this at zero means that your cache could potentially fill up with stale entries while newer entries won't be cached.
The number of seconds that a cache entry may remain on the garbage-collection list. This value provides a fail-safe in the event that a server process dies while executing a cached source file; if that source file is modified, the memory allocated for the old version will not be reclaimed until this TTL reached. Set to zero to disable this feature.
On by default, but can be set to off and used in conjunction with positive apc.filters so that files are only cached if matched by a positive filter.
A comma-separated list of POSIX extended regular expressions. If any pattern matches the source filename, the file will not be cached. Note that the filename used for matching is the one passed to include/require, not the absolute path. If the first character of the expression is a + then the expression will be additive in the sense that any files matched by the expression will be cached, and if the first character is a - then anything matched will not be cached. The - case is the default, so it can be left off.
If compiled with MMAP support by using --enable-mmap this is the mktemp-style file_mask to pass to the mmap module for determing whether your mmap'ed memory region is going to be file-backed or shared memory backed. For straight file-backed mmap, set it to something like /tmp/apc.XXXXXX (exactly 6 Xs). To use POSIX-style shm_open/mmap put a .shm somewhere in your mask. e.g. /apc.shm.XXXXXX You can also set it to /dev/zero to use your kernel's /dev/zero interface to anonymous mmap'ed memory. Leaving it undefined will force an anonymous mmap.
On very busy servers whenever you start the server or modify files you can create a race of many processes all trying to cache the same file at the same time. This option sets the percentage of processes that will skip trying to cache an uncached file. Or think of it as the probability of a single process to skip caching. For example, setting apc.slam_defense to 75 would mean that there is a 75% chance that the process will not cache an uncached file. So, the higher the setting the greater the defense against cache slams. Setting this to 0 disables this feature.
When you modify a file on a live web server you really should do so in an atomic manner. That is, write to a temporary file and rename (mv) the file into its permanent position when it is ready. Many text editors, cp, tar and other such programs don't do this. This means that there is a chance that a file is accessed (and cached) while it is still being written to. This apc.file_update_protection setting puts a delay on caching brand new files. The default is 2 seconds which means that if the modification timestamp (mtime) on a file shows that it is less than 2 seconds old when it is accessed, it will not be cached. The unfortunate person who accessed this half-written file will still see weirdness, but at least it won't persist. If you are certain you always atomically update your files by using something like rsync which does this correctly, you can turn this protection off by setting it to 0. If you have a system that is flooded with io causing some update procedure to take longer than 2 seconds, you may want to increase this a bit.
Mostly for testing and debugging. Setting this enables APC for the CLI version of PHP. Normally you wouldn't want to create, populate and tear down the APC cache on every CLI request, but for various test scenarios it is handy to be able to enable APC for the CLI version of APC easily.
Prevent files larger than this value from getting cached. Defaults to 1M.
Be careful if you change this setting. The default is for this to be On which means that APC will stat (check) the script on each request to see if it has been modified. If it has been modified it will recompile and cache the new version. If you turn this setting off, it will not check. That means that in order to have changes become active you need to restart your web server. On a production server where you rarely change the code, turning stats off can produce a significant performance boost.
For included/required files this option applies as well, but note that if you are using relative path includes (any path that doesn't start with / on Unix) APC has to check in order to uniquely identify the file. If you use absolute path includes APC can skip the stat and use that absolute path as the unique identifier for the file.
Array of cached data (and meta-data), or FALSE on failure
Megjegyzés: apc_cache_info() will raise a warning if it is unable to retrieve APC cache data. This typically occurs when APC is not enabled.
If cache_type is "user", the user cache will be cleared; otherwise, the system cache (cached files) will be cleared.
Példa 1. A apc_cache_info() example
A fenti példa valami ilyesmi kimenetet ad:
|
If cache_type is "user", the user cache will be cleared; otherwise, the system cache (cached files) will be cleared.
define() is notoriously slow. Since the main benefit of APC is to increase the performance of scripts/applications, this mechanism is provided to streamline the process of mass constant definition.
Megjegyzés: To remove a set of stored constants (without clearing the entire cache), an empty array may be passed as the constants parameter, effectively clearing the stored value(s).
The key serves as the name of the constant set being stored. This key is used to retrieve the stored constants in apc_load_constants().
An associative array of constant_name => value pairs. The constant_name must follow the normal constant naming rules. value must evaluate to a scalar value.
The default behaviour for constants is to be declared case-sensitive; i.e. CONSTANT and Constant represent different values. If this parameter evaluates to FALSE the constants will be declared as case-insensitive symbols.
The name of the constant set (that was stored with apc_define_constants()) to be retrieved.
The default behaviour for constants is to be declared case-sensitive; i.e. CONSTANT and Constant represent different values. If this parameter evaluates to FALSE the constants will be declared as case-insensitive symbols.
Megjegyzés: Unlike many other mechanisms in PHP, variables stored using apc_store() will persist between requests (until the value is removed from the cache).
Store the variable using this name. keys are cache-unique, so storing a second value with the same key will overwrite the original value.
The variable to store
Time To Live; store var in the cache for ttl seconds. After the ttl has passed, the stored variable will be expunged from the cache (on the next request). If no ttl is supplied (or if the ttl is 0), the value will persist until it is removed from the cache manually, or otherwise fails to exist in the cache (clear, restart, etc.).
APD is the Advanced PHP Debugger. It was written to provide profiling and debugging capabilities for PHP code, as well as to provide the ability to print out a full stack backtrace. APD supports interactive debugging, but by default it writes data to trace files. It also offers event based logging so that varying levels of information (including function calls, arguments passed, timings, etc.) can be turned on or off for individual scripts.
| Figyelem |
APD is a Zend Extension, modifying the way the internals of PHP handle function calls, and thus may or may not be compatible with other Zend Extensions (for example Zend Optimizer). |
APD is currently available as a PECL extension from http://pecl.php.net/package/apd. Make sure you have installed the CGI version of PHP and it is available in your current path along with the phpize script.
Run the following command to download, build, and install the latest stable version of APD:
pear install apd |
This automatically installs the APD Zend module into your PHP extensions directory. It is not mandatory to keep it there; you can store the module in any directory PHP can read as long as you set the zend_extension parameter accordingly.
Windows users can download the extension dll php_apd.dll from http://snaps.php.net/win32/PECL_STABLE/.
In your INI file, add the following lines:
zend_extension = /absolute/path/to/apd.so apd.dumpdir = /absolute/path/to/trace/directory apd.statement_tracing = 0 |
Depending on your PHP build, the zend_extension directive can be one of the following:
zend_extension (non ZTS, non debug build) zend_extension_ts ( ZTS, non debug build) zend_extension_debug (non ZTS, debug build) zend_extension_debug_ts ( ZTS, debug build) |
To build APD under Windows you need a working PHP compilation environment as described on http://php.net/ -- basically, it requires you to have Microsoft Visual C++, win32build.zip, bison/flex, and some know how to get it to work. Also ensure that adp.dsp has DOS line endings; if it has unix line endings, Microsoft Visual C++ will complain about it.
Az alábbi függvények viselkedése befolyásolható a php.ini segítségével.
Táblázat 1. APD Configuration Options
| Name | Default | Changeable | Changelog |
|---|---|---|---|
| apd.dumpdir | NULL | PHP_INI_ALL | |
| apd.statement_tracing | "0" | PHP_INI_ALL |
A témába vágó konfigurációs direktívák rövid leírása
Sets the directory in which APD writes profile dump files. You can specify an absolute path or a relative path.
You can specify a different directory as an argument to apd_set_pprof_trace().
Specfies whether or not to do per-line tracings. Turning this on (1) will impact the performance of your application.
As the first line of your PHP script, call the apd_set_pprof_trace() function to start the trace:
apd_set_pprof_trace(); |
You can insert the line anywhere in your script, but if you do not start tracing at the beginning of your script you discard profile data that might otherwise lead you to a performance bottleneck.
Now run your script. The dump output will be written to apd.dumpdir/pprof_pid.ext.
Tipp: If you're running the CGI version of PHP, you will need to add the '-e' flag to enable extended information for apd to work properly. For example: php -e -f script.php
To display formatted profile data, issue the pprofp command with the sort and display options of your choice. The formatted output will look something like:
bash-2.05b$ pprofp -R /tmp/pprof.22141.0 Trace for /home/dan/testapd.php Total Elapsed Time = 0.00 Total System Time = 0.00 Total User Time = 0.00 Real User System secs/ cumm %Time (excl/cumm) (excl/cumm) (excl/cumm) Calls call s/call Memory Usage Name -------------------------------------------------------------------------------------- 100.0 0.00 0.00 0.00 0.00 0.00 0.00 1 0.0000 0.0009 0 main 56.9 0.00 0.00 0.00 0.00 0.00 0.00 1 0.0005 0.0005 0 apd_set_pprof_trace 28.0 0.00 0.00 0.00 0.00 0.00 0.00 10 0.0000 0.0000 0 preg_replace 14.3 0.00 0.00 0.00 0.00 0.00 0.00 10 0.0000 0.0000 0 str_replace |
The -R option used in this example sorts the profile table by the amount of real time the script spent executing a given function. The "cumm call" column reveals how many times each function was called, and the "s/call" column reveals how many seconds each call to the function required, on average.
To generate a calltree file that you can import into the KCacheGrind profile analysis application, issue the pprof2calltree comand.
If you have comments, bugfixes, enhancements or want to help developing this beast, you can send an mail to apd@mail.communityconnect.com. Any help is very welcome.
This can be used to stop the running of your script, and await responses on the connected socket. To step the program, just send enter (a blank line), or enter a php command to be executed. A typical session using tcplisten would look like this.
bash#tcplisten localhost 7777
APD - Advanced PHP Debugger Trace File
---------------------------------------------------------------------------
Process Pid (6118)
Trace Begun at Sun Mar 10 23:13:12 2002
---------------------------------------------------------------------------
( 0.000000): apd_set_session_trace called at /home/alan/Projects/project2/test.
php:5
( 0.074824): apd_set_session_trace_socket() at /home/alan/Projects/project2/tes
t.php:5 returned. Elapsed (0.074824)
( 0.074918): apd_breakpoint() /home/alan/Projects/project2/test.php:7
++ argv[0] $(??) = 9
apd_breakpoint() at /home/alan/Projects/project2/test.php:7 returned. Elapsed (
-2089521468.1073275368)
>\n
statement: /home/alan/Projects/project2/test.php:8
>\n
statement: /home/alan/Projects/project2/test.php:8
>\n
statement: /home/alan/Projects/project2/test.php:10
>apd_echo($i);
EXEC: apd_echo($i);
0
>apd_echo(serialize(apd_get_active_symbols()));
EXEC: apd_echo(serialize(apd_get_active_symbols()));
a:47:{i:0;s:4:"PWD";i:1;s:10:"COLORFGBG";i:2;s:11:"XAUTHORITY";i:3;s:14:"
COLORTERM_BCE";i:4;s:9:"WINDOWID";i:5;s:14:"ETERM_VERSION";i:6;s:16:"SE
SSION_MANAGER";i:7;s:4:"PS1";i:8;s:11:"GDMSESSION";i:9;s:5:"USER";i:10;s:5:"
MAIL";i:11;s:7:"OLDPWD";i:12;s:5:"LANG";i:13;s:10:"COLORTERM";i:14;s:8:"DISP
LAY";i:15;s:8:"LOGNAME";i:16;s:6:"
>apd_echo(system('ls /home/mydir'));
........
>apd_continue(0); |
(no version information, might be only in CVS)
apd_callstack -- Returns the current call stack as an arrayBehaves like perl's Carp::cluck. Throw a warning and a callstack. The default line delimiter is "<BR />\n".
Usually sent via the socket to restart the interpreter.
(no version information, might be only in CVS)
apd_croak -- Throw an error, a callstack and then exitBehaves like perl's Carp::croak. Throw an error, a callstack and then exit. The default line delimiter is "<BR />\n".
(no version information, might be only in CVS)
apd_dump_function_table -- Outputs the current function table(no version information, might be only in CVS)
apd_dump_persistent_resources -- Return all persistent resources as an arrayReturn all persistent resources as an array.
(no version information, might be only in CVS)
apd_dump_regular_resources -- Return all current regular resources as an arrayReturn all current regular resources as an array.
Usually sent via the socket to request information about the running script.
(no version information, might be only in CVS)
apd_get_active_symbols -- Get an array of the current variables names in the local scopeReturns the names of all the variables defined in the active scope, (not their values)
Starts debugging to {dump_directory}/pprof_{process_id}, if dump_directory is not set, then the apd.dumpdir setting from the php.ini file is used.
Starts debugging to {dump_directory}/apd_dump_{process_id}, if dump_directory is not set, then the apd.dumpdir setting from the php.ini file is used.
debug_level is an integer which is formed by adding together the following values:
FUNCTION_TRACE 1
ARGS_TRACE 2
ASSIGNMENT_TRACE 4
STATEMENT_TRACE 8
MEMORY_TRACE 16
TIMING_TRACE 32
SUMMARY_TRACE 64 |
I would seriously not recommend using MEMORY_TRACE. It is very slow and does not appear to be accurate (great, huh?) also ASSIGNMENT_TRACE is not implemented. So, to turn on all functional traces (TIMING, FUNCTIONS, ARGS SUMMARY (like strace -c)) use the value 99
(no version information, might be only in CVS)
apd_set_session -- Changes or sets the current debugging levelThis can be used to increase or decrease debugging in a different area of your application,.debug_level is an integer which is formed by adding together the following values:
FUNCTION_TRACE 1
ARGS_TRACE 2
ASSIGNMENT_TRACE 4
STATEMENT_TRACE 8
MEMORY_TRACE 16
TIMING_TRACE 32
SUMMARY_TRACE 64 |
(no version information, might be only in CVS)
apd_set_socket_session_trace -- Starts the remote session debuggingConnects to the tcp server (eg. tcplisten) specified IP or Unix Domain socket (like a file), and sends debugging data to the socket. You can use any port, but higher numbers are better as most of the lower numbers may be used by other system services.
the socket_type can be APD_AF_UNIX (for file based sockets) or APD_AF_INET (for standard tcp/ip)
debug_level is an integer which is formed by adding together the following values:
FUNCTION_TRACE 1
ARGS_TRACE 2
ASSIGNMENT_TRACE 4
STATEMENT_TRACE 8
MEMORY_TRACE 16
TIMING_TRACE 32
SUMMARY_TRACE 64 |
I would seriously not recommend setting the value to 'zero' to start with, and use the breakpoint methods to start debugging at a specific place in the file.
Syntax similar to create_function(). Overrides built-in functions (replaces them in the symbol table).
Ezekkel a függvényekkel különféle módon változtathatók, módosíthatók a tömbök. A tömbök elengedhetetlenek változók sorozatának tárolásához, rendezéséhez, igazgatásához és azok változtatásához.
A PHP az egy- és többdimenziós tömböket is támogatja, amelyeket akár "manuálisan" vagy valamilyen függvénnyel is létre lehet hozni. Vannak bizonyos adatbázis-kezelő függvények, amelyek adatbázis-lekérdezések alapján töltenek fel tömböket, és vannak, amelyek tömböket adnak vissza.
Nézd át a Tömbök fejezetet, ahol részletes leírást található a PHP-s tömbök megvalósításáról és működéséről. Hasznos információk olvashatók a Tömb operátorok oldalon arról, mi módon lehet még a tömbökön műveleteket végezni.
Az itt leírt függvények használatához semmilyen külső függvénykönyvtár megléte nem szükségeltetik.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Az itt felsorolt konstansok mindig elérthetőek, mivel részei a PHP alaptelepítésének.
CASE_LOWER az array_change_key_case() függvény paramétereként használható, és arra utasítja a függvényt, hogy a tömb kulcsait cserélje kisbetűs megfelelőikre. Ez az array_change_key_case() alapértelmezésbeli viselkedése is.
CASE_LOWER az array_change_key_case() függvény paramétereként használható, és arra utasítja a függvényt, hogy a tömb kulcsait cserélje nagybetűs megfelelőikre.
Rendezési irány flag-ek:
SORT_ASC - az array_multisort() használja a növekvő sorrend megadására
SORT_DESC - az array_multisort() használja a csökkenő sorrend megadására
Rendezés típus flag-ek: bizonyos rendezőfüggvények alkalmazzák
SORT_REGULAR - hogy a tömbelemek a megszokott módon legyenek sorrendezve.
SORT_NUMERIC - hogy a tömbelemek számszerűen értelmezve legyenek sorrendezve.
SORT_STRING - hogy a tömbelemek string-ként kerüljenek sorrendezésre.
A SORT_LOCALE_STRING az aktuálos locale beállítás figyelembevételével hasonlítja össze a kapott értékeket. Ez a lehetőség a PHP 4.4.0 és 5.0.2 változataival lett bevezetve.
(PHP 4 >= 4.2.0, PHP 5)
array_change_key_case -- visszaad egy kis vagy nagybetűsre cserélt string indexű tömbötA array_change_key_case() kis vagy nagybetűsre cseréli az input tömb string típusú indexeit A változtatást az elhagyható case paraméter szabályozza, amelynek két állandót lehet átadni: CASE_UPPER és CASE_LOWER, az alapértelmezés a CASE_LOWER. A numerikus indexet változatlanul hagyja a függvény.
Amennyiben a tömbben több olyan kulcs is szerepel, amelyek e függvény alkalmazásakor összeütközésbe kerülnének (mint például a "kUlcs" és a "KUlCs" néven futó tömbindexek), a tömbben háttrébb szereplő felül fogja írni tartalmával az előzőt.
A array_chunk() feloszt egy tömböt több tömbre a size értéke alapján. A legutolsó tömbben elképzelhető, hogy ennél kevesebb elem szerepel. A tömböket egy többdimenziós tömb elemeiként adja vissza, amely 0-tól kezdve numerkius indexelt.
A lehetséges preserve_keys paraméter TRUE-ra állításával, kikényszeríthető, hogy az eredeti tömb indexelését megtartsák a visszaadott tömbdarabok. Ha e paraméter értéke FALSE, akkor minden tömbdarabban az elemek sorszámozása 0-tól újra kezdődik. Az alapértelmezés az utóbbi: FALSE.
Példa 1. array_chunk() példa
A fenti példa a következő kimenetet adja:
|
Returns an array by using the values from the keys array as keys and the values from the values array as the corresponding values.
Returns FALSE if the number of elements for each array isn't equal or if the arrays are empty.
See also array_merge(), array_walk(), and array_values().
Az array_count_values() olyan tömböt ad vissza, amelynek a kulcsai az input tömb értékei és az input tömbbeli előfordulási gyakoriságuk a hozzájuk tartozó értékek.
Lásd még: count(), array_unique(), array_values() és count_chars().
(PHP 4 >= 4.3.0, PHP 5)
array_diff_assoc -- Computes the difference of arrays with additional index checkarray_diff_assoc() returns an array containing all the values from array1 that are not present in any of the other arguments. Note that the keys are used in the comparison unlike array_diff().
Példa 1. array_diff_assoc() example
A fenti példa a következő kimenetet adja:
|
In our example above you see the "a" => "green" pair is present in both arrays and thus it is not in the ouput from the function. Unlike this, the pair 0 => "red" is in the ouput because in the second argument "red" has key which is 1.
Two values from key => value pairs are considered equal only if (string) $elem1 === (string) $elem2 . In other words a strict check takes place so the string representations must be the same.
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example, array_diff_assoc($array1[0], $array2[0]);.
See also array_diff(), array_intersect(), and array_intersect_assoc().
array_diff_key() returns an array containing all the values of array1 that have keys that are not present in any of the other arguments. Note that the associativity is preserved. This function is like array_diff() except the comparison is done on the keys instead of the values.
Példa 1. array_diff_key() example
A fenti példa a következő kimenetet adja:
|
The two keys from the key => value pairs are considered equal only if (string) $key1 === (string) $key2 . In other words a strict type check is executed so the string representation must be the same.
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using array_diff_key($array1[0], $array2[0]);.
See also array_diff(), array_udiff() array_diff_assoc(), array_diff_uassoc(), array_udiff_assoc(), array_udiff_uassoc(), array_diff_ukey(), array_intersect(), array_intersect_assoc(), array_intersect_uassoc(), array_intersect_key() and array_intersect_ukey().
(PHP 5)
array_diff_uassoc -- Computes the difference of arrays with additional index check which is performed by a user supplied callback functionarray_diff_uassoc() returns an array containing all the values from array1 that are not present in any of the other arguments. Note that the keys are used in the comparison unlike array_diff().
This comparison is done by a user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. This is unlike array_diff_assoc() where an internal function for comparing the indices is used.
Példa 1. array_diff_uassoc() example
A fenti példa a következő kimenetet adja:
|
In our example above you see the "a" => "green" pair is present in both arrays and thus it is not in the ouput from the function. Unlike this, the pair 0 => "red" is in the ouput because in the second argument "red" has key which is 1.
The equality of 2 indices is checked by the user supplied callback function.
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example, array_diff_uassoc($array1[0], $array2[0], "key_compare_func");.
See also array_diff(), array_diff_assoc(), array_udiff(), array_udiff_assoc(), array_udiff_uassoc(), array_intersect(), array_intersect_assoc(), array_uintersect(), array_uintersect_assoc() and array_uintersect_uassoc().
(PHP 5 >= 5.1.0RC1)
array_diff_ukey -- Computes the difference of arrays using a callback function on the keys for comparisonarray_diff_ukey() returns an array containing all the values of array1 that have keys that are not present in any of the other arguments. Note that the associativity is preserved. This function is like array_diff() except the comparison is done on the keys instead of the values.
This comparison is done by a user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first key is considered to be respectively less than, equal to, or greater than the second.
Példa 1. array_diff_ukey() example
A fenti példa a következő kimenetet adja:
|
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using array_diff_ukey($array1[0], $array2[0], 'callback_func');.
See also array_diff(), array_udiff() array_diff_assoc(), array_diff_uassoc(), array_udiff_assoc(), array_udiff_uassoc(), array_diff_key(), array_intersect(), array_intersect_assoc(), array_intersect_uassoc(), array_intersect_key() and array_intersect_ukey().
Az array_diff() olyan tömböt ad vissza, amely azokat az elemeket tartalmazza, amelyek csak array1-ben szerepelnek és semelyik másik paraméterként átadott tömbben nem. Az indexelést megőrzi.
Példa 1. array_diff() példa
A $tomb1-ben előforduló többszörös értékeket ugyanúgy kezeli a függvény. A példa kiemenete a következő lesz:
|
Megjegyzés: Két elem akkor és csakis akkor tekinthető egyenlőnek, ha (string) $elem1 === (string) $elem2, azaz ha sztring ábrázolásuk megegyezik.
Megjegyzés: Ez a függvény csak egydimenziós tömbökön működik, illetve többdimenzós tömbök első dimenziójában. Ha további dimenziókon kell használni, akkor a array_diff($tomb1[0], $tomb2[0]); formában kell meghívni.
| Figyelem |
PHP 4.0.4-ben hibásan működött! |
Lásd még: array_diff_assoc(), array_intersect() és array_intersect_assoc()!
Az array_fill() a num paraméterben megadott számú elemmel egy tömböt hoz létre, amelyben minden elem value értékű és az indexelésük start_index-től kezdődik.
Lásd még: str_repeat() és range()!
Az array_filter() végigszalad a megadott tömb minden elemén, annak értékét átadva a function paraméterben megadott függvénynek. Ha ez a függvény TRUE válasszal tér vissza, az adott tömbelem bekerül a szűrés eredményét képező tömbbe. A kulcsokat a függvény megőrzi.
Példa 1. array_filter() példa
A fenti példa a következő kimenetet adja:
|
A feldolgozandó tömböt a visszahívott függvényen belül nem lehet megváltoztatni, tehát nem lehet egyik vagy másik elemét, esetleg az egész tömböt törölni. Ha ez mégis megtörténik, akkor ennek a függvénynek a viselkedését nem lehet megjósolni.
Ha a function paramétert elhagyjuk, az array_filter() minden olyan tömbelemet ki fog hagyni, melyeknek tartalma a FALSE értékkel egyenértékű. Hogy mi alapján dől ez el, bővebben a Konvertálás logikai értékké oldalon olvashatsz.
Lásd még: array_reduce(), array_map() és array_walk().
Az array_flip() felcseréli a tömb elemeit és kulcsait egymással, úgyhogy a trans tömb értékei lesznek az új kulcsok és a kulcsai pedig a hozzátartozó értékek.
Figyelj arra, hogy a trans elemértékeinek érvényes kulcsoknak kell lenniük, azaz vagy integer vagy string típusúaknak. Egy figyelmeztető "nem fatális" hibaüzenetet (warning) küld, ha az elemérték típusa nem megfelelő, és a kérdéses kulcs - érték pár nem lesz felcserélve.
Ha egy érték többször szerepel, akkor a legutolsó kulcsot fogja használni ahhoz az értékhez, és a többit figyelmen kívül hagyja.
Az array_flip() FALSE-tal tér vissza sikertelenség esetén.
Lásd még: array_values(), array_keys() és array_reverse().
(PHP 4 >= 4.3.0, PHP 5)
array_intersect_assoc -- Computes the intersection of arrays with additional index checkarray_intersect_assoc() returns an array containing all the values of array1 that are present in all the arguments. Note that the keys are used in the comparison unlike in array_intersect().
In our example you see that only the pair "a" => "green" is present in both arrays and thus is returned. The value "red" is not returned because in $array1 its key is 0 while the key of "red" in $array2 is 1.
The two values from the key => value pairs are considered equal only if (string) $elem1 === (string) $elem2 . In other words a strict type check is executed so the string representation must be the same.
See also array_intersect(), array_uintersect_assoc(), array_intersect_uassoc(), array_uintersect_uassoc(), array_diff() and array_diff_assoc().
(PHP 5 >= 5.1.0RC1)
array_intersect_key -- Computes the intersection of arrays using keys for comparisonarray_intersect_key() returns an array containing all the values of array1 which have matching keys that are present in all the arguments.
Példa 1. array_intersect_key() example
A fenti példa a következő kimenetet adja:
|
In our example you see that only the keys 'blue' and 'green' are present in both arrays and thus returned. Also notice that the values for the keys 'blue' and 'green' differ between the two arrays. A match still occurs because only the keys are checked. The values returned are those of array1.
The two keys from the key => value pairs are considered equal only if (string) $key1 === (string) $key2 . In other words a strict type check is executed so the string representation must be the same.
See also array_diff(), array_udiff() array_diff_assoc(), array_diff_uassoc(), array_udiff_assoc(), array_udiff_uassoc(), array_diff_key(), array_diff_ukey(), array_intersect(), array_intersect_assoc(), array_intersect_uassoc() and array_intersect_ukey().
(PHP 5)
array_intersect_uassoc -- Computes the intersection of arrays with additional index check, compares indexes by a callback functionarray_intersect_uassoc() returns an array containing all the values of array1 that are present in all the arguments. Note that the keys are used in the comparison unlike in array_intersect().
The index comparison is done by a user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
Példa 1. array_intersect_uassoc() example
A fenti példa a következő kimenetet adja:
|
See also array_intersect(), array_intersect_assoc(), array_uintersect_assoc(), array_uintersect_uassoc(), array_intersect_key() and array_intersect_ukey().
(PHP 5 >= 5.1.0RC1)
array_intersect_ukey -- Computes the intersection of arrays using a callback function on the keys for comparisonarray_intersect_ukey() returns an array containing all the values of array1 which have matching keys that are present in all the arguments.
This comparison is done by a user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first key is considered to be respectively less than, equal to, or greater than the second.
Példa 1. array_intersect_ukey() example
A fenti példa a következő kimenetet adja:
|
In our example you see that only the keys 'blue' and 'green' are present in both arrays and thus returned. Also notice that the values for the keys 'blue' and 'green' differ between the two arrays. A match still occurs because only the keys are checked. The values returned are those of array1.
See also array_diff(), array_udiff() array_diff_assoc(), array_diff_uassoc(), array_udiff_assoc(), array_udiff_uassoc(), array_diff_key(), array_diff_ukey(), array_intersect(), array_intersect_assoc(), array_intersect_uassoc() and array_intersect_key().
Az array_intersect() olyan tömböt ad vissza, amely az array1 azon elemeit tartalmazza, amelyek minden paraméterként átadott tömbben megtalálhatók. Az indexelést megőrzi.
Megjegyzés: Két elem akkor és csakis akkor tekinthető egyenlőnek, ha (string) $elem1 === (string) $elem2, azaz ha sztring ábrázolásuk megegyezik.
Lásd még: array_intersect_assoc(), array_diff() és array_diff_assoc()!
Az array_key_exists() TRUE válasszal tér vissza, ha az adott key be van állítva a search tömbben. A key bármilyen lehetséges tömbindex érték lehet. Az array_key_exists() objektumokkal is tud dolgozni.
Megjegyzés: A PHP 4.0.6-ban a függvény neve key_exists() volt.
Példa 2. Az array_key_exists() és az isset() összehasonlítása Az isset() nem ad TRUE értéket olyan tömbmutatókra, amelyek NULL értékre mutatbak, míg az array_key_exists() megteszi ezt nekünk.
|
Lásd még: isset(), array_keys() és in_array().
Az array_keys() az input tömb összes - numerikus és sztring - típusú indexét (kulcsát) adja vissza.
Ha az elhagyható search_value is meg an adva, akkor csak azokkal a kulcsokkal tér vissza, amelyek a megadott értékhez tartoznak. Egyébként az input összes kulcsa átadásra kerül. A PHP 5-től használhatod a strict paramétert arra az esetre, ha az összehasonlítást típus szerint is akarod végezni (===)
Példa 1. array_keys() példa
A fenti példa a következő kimenetet adja:
|
Lásd még: array_values() és array_key_exists()!
Az array_map() olyan tömböt ad vissza, amelyben az arr1 tömb callback nevű függvény által kiszámolt értékei vannak. A callback függvény által fogadható paraméterek száma meg kell egyezzen az array_map()-nak átadott tömbök számával.
Példa 2. array_map() - több tömb használata
A fenti példa a következő kimenetet adja:
|
Több tömb használata esetén a tömbök hosszának meg kell egyeznie, mert a meghívott callback függvény párhuzomsan halad végig rajtuk mindig a megfelelő elemeket használva fel. Ha a tömbök nem megegyező méretűek, akkor a legrövidebbek üres elemekkel lesznek feltöltve.
Ennek a függvénynek érdekes felhasználási módja, hogy tömböket tartalmazó tömböt lehet vele létrehozni, ha a callback függvényként a NULL értéket adjuk át.
Példa 3. tömböket tartalmazó tömb létrehozása
A fenti példa a következő kimenetet adja:
|
Lásd még: array_filter(), array_reduce(), array_walk() és a visszahívható (callback) típusról szóló bejegyzést.
Az array_merge_recursive() egyesíti két vagy több tömb elemeit úgy, hogy az egyik elemeit a másik után fűzi, és visszadja az eredményül kapott tömböt.
Ha a megadott tömbökben ugyanolyan string kulcsok vannak, akkor az ezekhez tartozó elemértékeket egy tömbbe gyűjti össze. Ezt rekurzívan teszi a függvény, tehát ha az elemek egyike ugyancsak tömb, akkor ennek a tömbnek az elemeire is hasonlóképp lefut az egyesítő algoritmus. Ha viszont a numerikus indexek egyeznek meg, akkor a későbbi nem felülírja a korábbi értéket, hanem azok után fűzi.
Példa 1. array_merge_recursive() példa
Az $eredmeny tömb értéke:
|
Lásd még: array_merge()!
Az array_merge() egyesíti egy vagy több tömb elemeit úgy, hogy a második tömb elemeit hozzáfűzi az elsőéhez, és visszadja az eredményül kapott tömböt.
Ha a megadott tömbökben ugyanolyan string kulcsok vannak, akkor a későbbi felülírja az előzőt. Ha a tömböknek ugyanolyan numerikus indexei vannak, akkor nem ez történik, hanem mindegyiket új értékként a tömbbe illeszti.
Ha csak egy tömböt adsz meg, és az számokkal van indexelve, a kulcsok újraindexelődnek folytonos módon. Asszociatív tömbök esetén a többszörös bejegyzéseket az utolsó fogja képviselni. Lásd a harmadik példát.
Példa 1. array_merge() példa
Az $eredmeny tömb értéke:
|
Példa 2. Egyszerű array_merge() példa
Nem szabad elfelejteni, hogy a numerikus indexeket újraszámozza a függvény!
Ha teljesen meg kell őrizni a tömb indexeit, akkor a + operátorral kell egymáshoz fűzni azokat:
A numerikus kulcsot megőrizzük, ezért a társítás megmarad.
|
Példa 3. array_merge() példa
A fenti példa a következő kimenetet adja:
|
Megjegyzés: A közös indexek "elnyomják" egymást, ami azt jelenti, hogy az első index előforduláshoz tartozó értéket fogja az eredmény tartalmazni.
| Figyelem | |
Az array_merge() függvény viselkedése a PHP 5-ben megváltozott. Ellentétben a korábbiakkal, már csak tömb típusú paramétereket fogad el. Ez típuskényszerítéssel áthidalható. Hogy hogyan, lásd az alábbi példát:
|
Lásd még az array_merge_recursive() és az array_combine() függvényt valamint a tömboperátorokat!
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az array_multisort() arra használható, hogy egyszerre több tömböt vagy egy többdimenzós tömböt rendezzen sorba egy vagy dimenziója szerint.
Az asszociatív (string) kulcsokat megőrzi a rendezés során, a numerikus indexeket újraindexeli.
A megadott tömböket egy képzeletbeli, sorok alapján rendezendő táblázat oszlopainak tekinthetők. Ez hasonlít az SQL ORDER BY cikkelyének feladatára. Ez első tömb, ami alapján először rendez. Az ebben a tömbben levő ugyanolyan sorok (elemek) a soron következő tömb szerint lesznek tovább rendezve, és így tovább végig a tömbökön.
Ennek a függvénynek a argumentumlistája kicsit szokatlan, de nagyon rugalmas. A legelső paraméternek mindig tömbnek kell lennie, ezután minden paraméter lehet egy tömb vagy egy a következő rendezést szabályzó jelzőértékek közül.
Sorrendi jelzők:
SORT_ASC - növekvő sorrendbe rendez
SORT_DESC - csökkenő sorrendbe rendez
Rendezési jelzők:
SORT_REGULAR - megszokott módon hasonlítja össze az elemeket
SORT_NUMERIC - számként hasonlítja össze az elemeket
SORT_STRING - szövegként hasonlítja össze az elemeket
Nem lehet két ugyanolyan típusú jelzőt egymás után megadni. Ezek a jelzők csak a közvetlenül előttük álló tömb szerinti rendezést befolyásolják, minden tömb paraméternél az alapértelmezés lép életbe: SORT_ASC és SORT_REGULAR.
Példa 1. Több tömb alapján történő rendezés
A rendezés után az első tömb tartalma "10", "a", 100, 100, a másodiké 1, 1, "2", 3. A második tömb elemei az első tömb megegyező elemeinek megfelelően (100, 100) szintén rendezettek.
|
Példa 2. Többdimenziós tömbök rendezése
Ebben a példában a rendezés után az első tömb "10", 100, 100, 11, "a" (stringekként lett növekvő sorrendbe rendezve). A második tartalma 1, 3, "2", 2, 1 (számokként rendezve csökkenő sorrendbe).
|
Példa 3. Adatbázis eredményhalmazok rendezése Ebben a példában minden data tömbbeli elem egy táblabeli sornak felel meg. Példa adat:
Az adat egy tömb, melynek neve data. Ez például a mysql_fetch_assoc() függvény ciklusban való hívásával kapható meg.
Ebben a példában volume szerint csökkenőleg, edition szerint növekvőleg rendezünk. Van egy tömbünk a sorokról, de a array_multisort() oszlopokból álló tömböt vár, ezért a következő kódot használjuk, hogy megkapjuk az oszlopokat, majd elvégezzük a rendezést.
Az adathalmaz a rendezés után így néz ki:
|
Példa 4. Kis- és nagybetűk egyenlőek Mind a SORT_STRING mind a SORT_REGULAR esetén különbséget tesz a kis- és nagybetűk között, a nagybetűvel kezdődő stringek kisebbek mint a kisbetűvel kezdődőek. Ha azt akarod, hogy a rendezés ne tegyen különbséget a kis- és nagybetűk között, a rendezést a kisbetűssé alakított tömb szerint végezd.
A fenti példa a következő kimenetet adja:
|
Az array_pad() az input tömb pad_size paraméterben megadott méretre bővített másolatát adja vissza, amelyben az új elemeket a pad_value értékkel töltötte fel. Ha a pad_size pozitív szám, akkor a tömb végére kerülnek az új elemek, ha negatív, akkor az elejére. Ha a pad_size abszolút értéke kisebb vagy egyenlő a tömb méretével, akkor az input tömbön nem történik változtatás. Egyszerre maximum 1048576 elemmel növelhető meg egy tömb.
Lásd még: array_fill() és range()!
Az array_pop() kiveszi az array tömbből annak utolsó elemét, és ezt adja vissza. Ha az array tömb üres vagy nem tömb, akkor NULL-lal tér vissza.
Lásd még az array_push(), array_shift() és array_unshift() függvényeket!
array_product() returns the product of values in an array as an integer or float.
Az array_push() az array tömböt veremként kezeli, és annak a tetejére - a tömb végére - teszi a paraméterként megadott értékeket. Az array tömb mérete a hozzáfűzött elemek számával fog nőni. Ennek ugyanaz a hatása, mintha a:
<?php $tomb[] = $var; ?> |
A tömbbeli elemek új számával tér vissza.
Megjegyzés: Ha arra akarod használni az array_push() függvényt, hogy a tömb végére tegyél egyetlen elemet, használd inkább a $array[] = módszert, mivel az itt tárgyalt függvény alkalmazása erre a feladatra jóval erőforrásigényesebb.
Lásd még: array_pop(), array_shift() és array_unshift().
Az array_rand() különösen akkor hasznos, ha egy vagy több tömbbeli elemet kell véletlenszerűen kiválasztani. A függvény az input tömbből az elhagyható num_req paraméterben megadott számú elemet választja ki és adja vissza. A kívánt elemek száma alapértelmezás szerint 1.
Ha csak egy elemet választ ki, akkor az array_rand() ennek az elemnek az indexével tér vissza. Több elem esetén ezeknek az indexeiből alkotott tömbbel. Ezzel a megoldással kulcsokat és elemértékeket is véletlenszerűen ki lehet választani egy tömbből.
Megjegyzés: A 4.2.0 változattól kezdődően nincs már szükség a srand() vagy az mt_srand() függvény meghívására, a PHP maga megteszi ezt automatikusan.
Lásd még: shuffle().
(PHP 4 >= 4.0.5, PHP 5)
array_reduce -- elemi értékre csökkenti a tömböt tetszőleges függvény meghívásávalAz array_reduce() ismétlődve meghívja a function függvényt paraméterként az input tömb elemeivel, hogy végül egy elemi értékké alakítsa át a tömböt. Az elhagyható intial megadásával beállítható egy tetszőleges kezdő érték a folyamat legelején. Ha üres a tömb, akkor ez lesz a visszadott érték is.
Ennek eredménye: $b = 15, $c = 1200 (= 1*2*3*4*5*10) és $d = 1.
Lásd még: array_filter(), array_map(), array_unique() és array_count_values().
Az array_reverse() veszi az array tömböt, és visszaad egy olyan tömböt, amelyben elemek fordított sorrendben szerepelnek. Ha preserve_keys értéke TRUE, akkor megőrzi az elemek indexelését a visszaadandó tömbben.
Példa 1. array_reverse() példa
Ezután az $eredmeny és a $indexelt_eredmeny tömbnek ugyanazok az elemei lesznek, de az indexelésük eltérő. A $eredmeny és a $indexelt_bemenet így néz ki:
|
Megjegyzés: A második paraméter PHP 4.0.3-től használható.
Lásd még: array_flip().
Átnézi a haystack tömböt a needle elemet keresve, ha megtalálta, akkor visszaadja az indexét/kulcsát, egyébként FALSE-ot.
Megjegyzés: Ha a needle paraméternek egy stringet adsz meg, az összehasonlítás betűméret-érzékenyen fog történni.
Megjegyzés: PHP 4.2.0 előtti verziókban hiba esetén az array_search() NULL választ adott vissza FALSE helyett.
Ha a harmadik, strict paraméter értéke TRUE, akkor az array_search() a needle típusát is összeveti a haystack tömb elemeiével.
Ha a needle a haystack tömbben többször is előfordul, az elsőként megtalált kulcsot adja vissza. Ha az összes egyező tömbelem kulcsára szükséged van, használd inkább az array_keys() függvényt a search_value paraméter megfelelő beállítása mellett.
| Figyelem |
Ez a függvény a logikai típusú FALSE értékkel is visszatérhet, olyan nem logikai típusú értékek mellett, amik szintén FALSE értékként jelenhetnek meg (mint pl. 0 vagy ""). Olvasd el a Logikai típusról szóló részt további információkért. Használd a === operátort a visszatérési érték ellenőrzésére. |
Lásd még: array_keys(), array_values(), array_key_exists() és in_array().
Az array_shift() kilépteti az array tömb első elemét, és ezt adja vissza. Az array tömb eggyel kevesebb elemet fog tartalmazni, és minden eleme eggyel előrébb (első index felé) tolódik, és minden numerikus index módosul, hogy az indexelés 0-tól kezdődjön. A nem numerikus (asszociatív) indexelés nem változik. Ha a tömb üres volt, akkor NULL-lal tér vissza.
Megjegyzés: Ez a függvény reset()-et végez az áltata használt tömbön, a használat után.
Lásd még: array_unshift(), array_push() és array_pop()!
Az array_slice() függvény az array tömb offset és length paraméterek által meghatározott elemsorozatával tér vissza.
Nem negatív offset esetén, az elemsorozat ennyiedik sorszámú elemtől kezdődik, negatív offset esetén az array tömb végétől visszafelé számolva ennyiedik elemtől kezdődik.
Ha a length meg van adva és pozitív, akkor az elemsorozatba ennyi darab elem kerül bele. Negatív length esetén az elemsorozat az array tömb vége előtt ennyi darab elemmel "áll meg", amely azt jelenti, hogy az ezután következő elemek nem kerülnek bele a sorozatba. Ha nincs megadva a length, akkor az offset által meghatározott ponttól kezdve a tömb végéig minden elem belekerül a sorozatba.
Megjegyzés: Az array_slice() alapesetben újraindexeli az eredménytömböt. A PHP 5.0.2-től kezdődően megváltoztathatod ezt a viselkedést a preserve_keys paraméter TRUE-ra állításával.
Példa 1. array_slice() példák
A fenti példa a következő kimenetet adja:
|
Lásd még az array_splice() és az unset() függvényt!
Az array_splice() eltávolítja az input tömb offset és length paraméterek által meghatározott sorozatát, és helyébe - ha meg van adva - a replacement tömböt illeszti. Az eltávolított elemek tömbjével tér vissza.
Pozitív offset esetén, a törlendő elemsorozat ennyiedik sorszámú elemtől kezdődik, negatív offset esetén az array tömb végétől visszafelé számolva ennyiedik elemtől kezdődik.
Ha nincs megadva a length, akkor az offset által meghatározott ponttól kezdve a tömb végéig minden elemet eltávolít. Ha a length meg van adva és pozitív, akkor ennyi darab elem kerül törlésre. Negatív length esetén az array tömb végétől visszafelé ennyiedik elemig törlődik minden. Jótanácsként: ha a tömb végéig kell mindent lecserélni a replacement-re, akkor a count($input)-ot kell a length paraméterben megadni.
Ha a replacement tömb is meg van adva, akkor a törölt elemek helyére ennek a tömbnek az elemei kerülnek. Ha offset és length alapján nem történt törlés, akkor a replacement elemei az offset által mutatott helyre kerülnek beillesztésre. Fontos tudni, hogy a replacement tömb kulcsait a függvény nem tartja meg. Ha a replacement egy elemű, akkor nem szükséges array()-t használni, kivéve ha ez az egy elem maga is tömb kell legyen.
Az alábbi utasítások a $input étékét ugyanúgy módosítják:
Táblázat 1. array_splice() megfelelők
| array_push($bemenet, $x, $y) | array_splice($bemenet, count($bemenet), 0, array($x, $y)) |
| array_pop($bemenet) | array_splice($bemenet, -1) |
| array_shift($bemenet) | array_splice($bemenet, 0, 1) |
| array_unshift($bemenet, $x, $y) | array_splice($bemenet, 0, 0, array($x, $y)) |
| $bemenet[$x] = $y // olyan tömbök esetében ahol a kulcs egyenlő az elem sorszámával | array_splice($bemenet, $x, 1, $y) |
A törölt elemek tömbjével tér vissza a függvény.
Példa 1. array_splice() példák
|
Lásd még az array_slice(), unset() és array_merge() függvényeket!
Az array_sum() az array tömb elemeinek integer vagy float típusú értékével tér vissza.
Megjegyzés: A 4.2.1 verziót megelőzően a PHP módosította a paraméterként átadott tömböt, a sztringeket számmá konvertálta, ami majdnem mindig 0-val volt egyenlő.
(PHP 5)
array_udiff_assoc -- Computes the difference of arrays with additional index check, compares data by a callback functionarray_udiff_assoc() returns an array containing all the values from array1 that are not present in any of the other arguments. Note that the keys are used in the comparison unlike array_diff() and array_udiff(). The comparison of arrays' data is performed by using an user-supplied callback. In this aspect the behaviour is opposite to the behaviour of array_diff_assoc() which uses internal function for comparison.
Példa 1. array_udiff_assoc() example
A fenti példa a következő kimenetet adja:
|
In our example above you see the "1" => new cr(4) pair is present in both arrays and thus it is not in the ouput from the function.
For comparison is used the user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example, array_udiff_assoc($array1[0], $array2[0], "some_comparison_func");.
See also array_diff(), array_diff_assoc(), array_diff_uassoc(), array_udiff(), array_udiff_uassoc(), array_intersect(), array_intersect_assoc(), array_uintersect(), array_uintersect_assoc() and array_uintersect_uassoc().
(PHP 5)
array_udiff_uassoc -- Computes the difference of arrays with additional index check, compares data and indexes by a callback functionarray_udiff_uassoc() returns an array containing all the values from array1 that are not present in any of the other arguments. Note that the keys are used in the comparison unlike array_diff() and array_udiff(). The comparison of arrays' data is performed by using an user-supplied callback : data_compare_func. In this aspect the behaviour is opposite to the behaviour of array_diff_assoc() which uses internal function for comparison. The comparison of keys (indices) is done also by the callback function key_compare_func. This behaviour is unlike what array_udiff_assoc() does, since the latter compares the indices by using an internal function.
Példa 1. array_udiff_uassoc() example
A fenti példa a következő kimenetet adja:
|
In our example above you see the "1" => new cr(4) pair is present in both arrays and thus it is not in the ouput from the function. Keep in mind that you have to supply 2 callback functions.
For comparison is used the user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example, array_udiff_uassoc($array1[0], $array2[0], "data_compare_func", "key_compare_func");.
See also array_diff(), array_diff_assoc(), array_diff_uassoc(), array_udiff(), array_udiff_assoc(), array_intersect(), array_intersect_assoc(), array_uintersect(), array_uintersect_assoc() and array_uintersect_uassoc().
(PHP 5)
array_udiff -- Computes the difference of arrays by using a callback function for data comparisonarray_udiff() returns an array containing all the values of array1 that are not present in any of the other arguments. Note that keys are preserved. For the comparison of the data data_compare_func is used. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. This is unlike array_diff() which uses an internal function for comparing the data.
Példa 1. array_udiff() example
A fenti példa a következő kimenetet adja:
|
Megjegyzés: Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using array_udiff($array1[0], $array2[0], "data_compare_func");.
See also array_diff(), array_diff_assoc(), array_diff_uassoc(), array_udiff_assoc(), array_udiff_uassoc(), array_intersect(), array_intersect_assoc(), array_uintersect(), array_uintersect_assoc() and array_uintersect_uassoc().
(PHP 5)
array_uintersect_assoc -- Computes the intersection of arrays with additional index check, compares data by a callback functionarray_uintersect_assoc() returns an array containing all the values of array1 that are present in all the arguments. Note that the keys are used in the comparison unlike in array_uintersect(). The data is compared by using a callback function.
Példa 1. array_uintersect_assoc() example
A fenti példa a következő kimenetet adja:
|
For comparison is used the user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
See also array_uintersect(), array_intersect_assoc(), array_intersect_uassoc() and array_uintersect_uassoc().
(PHP 5)
array_uintersect_uassoc -- Computes the intersection of arrays with additional index check, compares data and indexes by a callback functionsarray_uintersect_uassoc() returns an array containing all the values of array1 that are present in all the arguments. Note that the keys are used in the comparison unlike in array_uintersect(). Both the data and the indexes are compared by using a callback functions.
Példa 1. array_uintersect_uassoc() example
A fenti példa a következő kimenetet adja:
|
For comparison is used the user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
See also array_uintersect(), array_intersect_assoc(), array_intersect_uassoc() and array_uintersect_assoc().
(PHP 5)
array_uintersect -- Computes the intersection of arrays, compares data by a callback functionarray_uintersect() returns an array containing all the values of array1 that are present in all the arguments. The data is compared by using a callback function.
Példa 1. array_uintersect() example
A fenti példa a következő kimenetet adja:
|
For comparison is used the user supplied callback function. It must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
See also array_intersect(), array_uintersect_assoc(), array_intersect_uassoc() and array_uintersect_uassoc().
Az array_unique() a bemenetként kapott array tömbből minden értéket egyszer vesz, és az így keletkezett tömbbel tér vissza.
Az indexelést megtartja. Az array_unique() először sorba rendezi a tömbértékeket, majd az összetartozó értékek közül az elsőként megtalált elem indexét tartja meg, a többi ezután következőt eldobja. Ez nem azt jelenti, hogy az eredeti tömbbeli legelső elem indexét tartja meg.
Megjegyzés: Két elem akkor és csakis akkor tekinthető egyenlőnek, ha (string) $elem1 === (string) $elem2, azaz ha sztring ábrázolásuk megegyezik.
Az array_unshift() az array tömb után megadott elemeket a tömb elejébe beszúrja. A beszúrandó elemeket listaként kezeli a függvény, így egymáshoz képesti sorrendjük nem változik meg. A numerikus indexek megváltoznak, 0-tól kezdve újraindexeli az elemeket, a szövegindexek nem változnak.
Az array elemeinek új számával tér vissza.
Lásd még: array_shift(), array_push() és array_pop()!
Az array_values() visszadja az összes input tömbben előforduló értéket. A létrehozott tömb numerikus indexelésű lesz.
Lásd még: array_keys().
Applies the user-defined function funcname to each element of the input array. This function will recur into deeper arrays. Typically, funcname takes on two parameters. The input parameter's value being the first, and the key/index second. If the optional userdata parameter is supplied, it will be passed as the third parameter to the callback funcname.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: If funcname needs to be working with the actual values of the array, specify the first parameter of funcname as a reference. Then, any changes made to those elements will be made in the original array itself.
Példa 1. array_walk_recursive() example
A fenti példa a következő kimenetet adja:
You may notice that the key 'sweet' is never displayed. Any key that holds an array will not be passed to the function. |
See also array_walk(), and a visszahívható (callback) típusról szóló bejegyzést.
A func paraméterben megadott nevű felhasználói függvényt alkalmazza az array tömb minden elemére. A func függvény hívásakor első paraméterként a tömbérték, másodikként az indexe kerül átadásra. Ha a userdata is szerepel, akkor ez lesz a harmadik paraméter. A func nevű függvénynek a felhasználó által definiáltnak kell lennie, és nem lehet natív PHP függvény. Emiatt nem lehet az array_walk()-nak például közvetlenül a str2lower()-t meghívni, hanem először létre kell hozni egy saját függvényt, majd ennek átadni a paramétereket.
Megjegyzés: A függvény neve helyett egy tömböt is átadhatsz, ami egy objektum referenciát és egy metódus nevet kell tartalmazzon.
Ha func két vagy három argumentumnál többet igényel a userdata-tól függően, akkor figyelmeztető hibaüzenet (warning) keletkezik minden alkalommal, amikor az array_walk() meghívja a func függvényt. Ezeket a figyelmeztetések elnyomhatók a '@' karaktert az array_walk() elé írva vagy az error_reporting() használatával.
Megjegyzés: Ha a func függvénynek a tényleges tömbértékekkel kell dolgoznia, akkor a func függvény első paraméterét referenciaként kell átadni. Ezután az ezen a változón végzett változtatás az eredeti tömbben is változást idéz elő.
Az array tömb func függvényen belüli módosítása megjósolhatatlan viselkedést eredményezhet.
Megjegyzés: Az index és a userdata értékek átadása a func függvénynek a 4.0 verziótól elérhető.
PHP 4-ben reset() függvényt szükség szerint meg kell hívni, mivel az array_walk() nem inicializálja a tömböt alapértelmezés szerint.
A feldolgozandó tömböt a visszahívott függvényen belül nem lehet megváltoztatni, tehát nem lehet egyik vagy másik elemét, esetleg az egész tömböt törölni. Ha ez mégis megtörténik, akkor ennek a függvénynek a viselkedését nem lehet megjósolni.
Példa 1. array_walk() példa
A fenti program kimenete:
|
A paramétereként átadott értékekből képzett tömböt ad vissza, az elemekhez az indexük is hozzárendelhető a => operátorral. Hogy mi is pontosan az a tömb, a array type oldalon olvashatsz részletesen.
Megjegyzés: Az array() nyelvi építőelem tömbök létrehozására, és nem szokványos függvény.
Az "index => érték" szintaxis - egymástól vesszővel elválasztva - meghatároz egy indexet a hozzátartozó értékkel. Az index lehet sztring vagy egész szám is. Ha nincs index megadva, akkor egy automatikusan generált egész szám lesz az elem indexe. (Az automatikus indexelés 0-tól kezdődik.) Ha az index egy egész szám, akkor a következőként generált index az eddigi legnagyobb egész számú indextől eggyel nagyobb szám lesz. Figyelj arra, hogy ha két azonos indexű elemet definiálsz, akkor az utolsó felülírja az elsőt.
Szintaktikailag nem probléma, ha az utolsó tömbelem után is található vessző.
A következő példák segítenek megérteni, hogyan lehet kétdimenziós tömböket létrehozni, asszociatív tömbök kulcsait megadni, illetve hogyan lehet helyeket kihagyni és folytatni numerikus indexelést.
Figyeld meg, hogy a 3. indexű elemet kétszer definiáltuk, és a végső értéke a 13. A 4. elemet a 8. után hoztuk létre, és a következő elemnek (19-nek) generált index értéke 9, mivel a legnagyobb létező index a tömbben a 8 volt.
Ez a példa egy olyan tömböt hoz létre, amelynek az indexelése 1-től kezdődik.
Ahogy Perlben is, hivatkozhatsz tömbelemekre duplaidézőjeles sztringek közepén is. PHP-ben viszont ezen hivatkozásokat kapcsos zárójelbe kell tenned.
Lásd még: array_pad(), list(), count(), foreach és range().
Ez a függvény úgy rendezi az array tömböt, hogy az indexek megtartják kapcsolatukat a hozzájuk rendelt tömb elemeivel. Főként akkor használják, ha az asszociatív tömbök rendezésénél az aktuális elemsorrend is fontos.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Példa 1. arsort() példa
A fenti példa a következő kimenetet adja:
|
A gyümölcsök az abc szerint fordított sorrendben vannak rendezve, és az indexek az eredeti elemekre mutatnak.
A rendezést befolyásolja a sort_flags paraméter, részletesebben lásd a sort() függvénynél!
Ez a függvény úgy rendezi az array tömböt, hogy az indexek megtartják kapcsolatukat a hozzájuk rendelt tömbelemekkel. Főként akkor használják, ha az asszociatív tömbök rendezésénél az aktuális elemsorrend is fontos.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Példa 1. asort() példa
A fenti példa a következő kimenetet adja:
|
A gyümölcsök az abc-nek megfelelően növekvő sorrendben vannak rendezve, és az indexek az eredeti elemekre mutatnak.
A rendezést befolyásolja a sort_flags paraméter, részletesebben lásd a sort() függvénynél!
A compact() változó számú paramétert fogad el. Minden paraméter lehet egy változónevet tartalmazó sztring vagy akár tömb is. A tömbben lehetnek újabb tömbök is, amelyek a változók neveit tárolják, a compact() rekurzívan kezeli ezt.
A compact() a neve alapján megkeresi a változót az aktuális szimbólumtáblában, és hozzáadja a kimeneti tömbhöz. A változó neve lesz a kulcs és a kulcshoz tartozó tömbérték pedig a változó értéke. Röviden, az extract()-tal ellentétesen működik. Az összes hozzáadott változót tároló kimeneti tömbbel tér vissza.
Az a sztring, amelynek megfelelő változó definiálatlan, ki lesz hagyva.
Példa 1. compact() példa
A $eredmeny értéke:
|
Lásd még: extract().
Visszaadja a var változó elemeinek számát, amely általában array(tömb) típusú, mivel az objektumokon kívül bármi másnak csak egy eleme lehet.
Obkektumok vizsgálata esetén, ha az SPL kiterjesztés telepítve van, lehetővé válik a count() működésének befolyásolása. Ezt a Countable interfész egyetlen, count() nevű eljárásának megadásával tudjuk megtenni. Ekkor ennek a függvénynek az eredménye lesz a count() visszaadott értéke.
Ha a var paraméter nem tömb vagy egy Countable interfésszel ellátott objektum, akkor 1-et ad vissza. Egyetlen kivétel a count(NULL), ez esetben 0 lesz a visszatérési érték.
Megjegyzés: A mode paraméter a PHP 4.2.0 változatától kezdve használható.
Ha a nem kötelezően megadandó mode paraméternek COUNT_RECURSIVE értéket (vagy 1-et) adunk meg, a függvény rekurzívan fogja megszámolni a tömbelemeket. Ilyen rekurzív megszámlálásnak például többdimenziós tömbök esetén van haszna. A mode paraméter alapértelmezett értéke 0. A count() nem észleli az esetleges végtelen ciklusokat kiváltó helyzeteket.
| Figyelem |
A count() 0-val térhet vissza definiálatlan változók esetén és üres tömbök esetén is. Az isset() segítségével lehet megvizsgálni, hogy a változó be van-e állítva. |
Olvasd át a kézikönyv Tömbök c. fejezetét a PHP-ban megvalósított tömbök részletes magyarazátáért.
Példa 2. Példa a count() rekurzív használatára ((PHP >= 4.2.0))
|
Lásd még: is_array(), isset() és strlen().
Minden tömbnek van egy ún. belső mutatója, amely a jelenlegi elemre mutat. A tömbbe beszúrt első elemre van inicializálva.
A current() függvény egyszerűen visszaadja a belső mutató által megjelölt tömbelem értékét. A mutató soha nem mozdul el erről az elemről. Ha a belső mutató az elemlista vége mögé mutat, akkor current() függvény FALSE-ot ad vissza.
| Figyelem |
Ha a tömb üres elemeket tartalmaz (0 vagy "" - üres string), akkor ez a függvény az ilyen elemeknél FALSE-ot ad vissza. Ez lehetetlenné teszi annak megállapítását a current() függvénnyel, hogy valóban a lista végére került-e a mutató. Az each() függvénnyel helyesen végig lehet lépkedni egy üres elemeket tartalmazó tömbön. |
Példa 1. Example use of current() and friends
|
(PHP 3, PHP 4, PHP 5)
each -- visszaadja a tömb pillanatnyilag kijelölt elemét és lépteti a belső mutatótAz each() visszaadja az array tömb jelenlegi index-érték párját, és előre mozgatja a tömb belső mutatóját. Ez a index-érték pár egy négyelemű tömbben kerül visszaadásra az alábbi kulcsokkal: 0, 1, key, and value, valamint az alábbi elemekkel. 0, 1,key és value. A 0 és a key tartalmazza a tömbelem kulcsát, 1 és value pedig az adatokat.
Ha a belső mutató az elemlista vége mögé mutat, akkor each() függvény FALSE-ot ad vissza.
$bigyo tartalma most:
Array (
1 => bob
value => bob
0 => 0
key => 0
) |
<?php
$ize = array ("Robert" => "Bob", "Seppo" => "Sepi");
$bigyo = each ($ize);
print_r($bigyo);
?> |
$bigyo tartalma most:
Array (
1 => Bob
value => Bob
0 => Robert
key => Robert
) |
Az each()-et a list()-tel együtt szokás használni tömbök bejárására, mint például a $_POST:
Az each()() függvény lefutása után a belső tömbmutató a tömb következő elemére ugrik, vagy az utolsó elemre, ha a tömb végén áll a mutató. Használd a reset()-et, ha újból végig kell lépkedni a tömbön.
Lásd még: key(), list(), current(), reset(), next(), prev() és foreach!
Az end() az array tömb belső mutatóját annak utolsó elemére állítja, valamit ezen elem értékét visszaadja.
Ez a függvény arra szolgál, hogy egy tömb tartalma alapján változókat helyezzen el az aktuális szimbólumtáblában. A paraméterként kapott var_array tömb kulcsait tekinti a változók neveinek és a tömbelemek értékeit a változók tartalmának. Minden kulcs-érték párból készül egy változó a szimbólumtáblában, az extract_type és prefix paraméterektől függően.
Megjegyzés: PHP 4.0.5-től kezdve a beillesztett változók számával tér vissza a függvény.
Megjegyzés: EXTR_IF_EXISTS és EXTR_PREFIX_IF_EXISTS 4.2.0 verzótól használhatók.
Megjegyzés: EXTR_REFS 4.3.0-tól használható.
Az extract() megvizsgál minden kulcsot (indexet), hogy az lehet-e egy érvényes változónév vagy sem, és hogy ilyen nevű változó létezik-e már a szimbólumtáblában (ütközés). Az érvénytelen változónevek és ütközések az extract_type paraméterben megadottak szerint lesz kezelve. Lehetséges értékei:
Ütközéskor felülírja a már létező változót.
Ütközéskor nem írja felül a létező változót.
Ütközéskor a létrehozandó változó neve elé prefix kerül.
Minden létrehozandó változó neve elé prefix kerül. PHP 4.0.5-től kezdve ez érvényes a numerikus indexű elemekre is.
Minden érvénytelen nevű változónév elé a prefix kerül. PHP 4.0.5-től kezdve használható ez beállítás.
Csak akkor írja felül az adott nevű változót, ha az már létezik az aktuális szimbólimtáblában, egyébként nem csinál semmit. Ez hasznos lehet, ha : érvényes változókat előre definiálni, majd létrehozni a $_REQUEST tömbön kívül definiált változókat. PHP 4.2.0-től használható.
Csak akkor hozza létre a toldalékolt nevű változót, ha annak a toldalék nélküli megfelelője már létezik már létezik az aktuális szimbólimtáblában. PHP 4.2.0-től használható.
A változókat referenciaként bontja ki, ami valójában azt jelenti, hogy a létrehozott változók referenciaként hivatkoznak az eredeti, var_array paraméterben átadott tömb elemeinek értékeire. Ez a módosító tetszés szerint önállóan vagy más módosítókkal logikai VAGY kapcsolattal együtt használható a extract_type paraméter értékeként. Ez a kapcsoló PHP 4.3.0. verziójától használható.
Ha nincs megadva az extract_type, akkor EXTR_OVERWRITE az alapértelmezés.
A prefix csak akkor szükséges, ha az extract_type EXTR_PREFIX_SAME, EXTR_PREFIX_ALL, EXTR_PREFIX_INVALID vagy EXTR_PREFIX_IF_EXISTS értékű. Ha prefixszel ellátott változónév sem érvényes, akkor az nem kerül bele a szimbólumtáblába.
Az extract() a sikeresen beillesztett változók számával tér vissza.
Az extract függvény egy lehetséges használata azoknak a változóknak a szimbólumtáblába importálása, amelyeket a wddx_deserialize() adott vissza egy asszociatív tömbben.
Példa 1. extract() példa
|
A fenti példa ezt eredményezi:
kék, nagy, gömb, közepes |
A $méret változó nem lett felülírva az EXTR_PREFIX_SAME megadása miatt, amely azt eredményezte, hogy ehelyett a $wddx_méret változóba került az új érték. Ha EXTR_SKIP-et használtunk volna, akkor a $wddx_méret sem került volna létrehozásra. Az EXTR_OVERWRITE pedig azt okozta volna, hogy a $méret értéke "közepes"-re változott volna. Az EXTR_PREFIX_ALL-lal pedig minden változó neve wddx előtaggal kezdődne: $wddx_szín, $wddx_méret és $wddx_alak.
Asszociatív tömböket kell használni, mert a numerikusan indexeltek nem adnak eredményt, kivéve EXTR_PREFIX_ALL vagy EXTR_PREFIX_INVALID jelzők használatakor.
Lásd még: compact()!
Átnézi a haystack tömböt a needle elemet keresve, ha megtalálta, akkor TRUE-t ad vissza, egyébként FALSE-ot.
Ha a strict harmadik paraméter értéke TRUE, akkor az in_array() a needle típusát is összeveti a haystack tömb elemeiével.
Megjegyzés: Ha a needle paraméter sztring, akkor az összehasonlítás kis- és nagybetűk különbözőségére érzékeny.
Megjegyzés: A PHP 4.2.0 verziója előtt a needle paraméter nem lehetett tömb.
Példa 3. in_array() with an array as needle
|
'ph'-t megtaláltam. 'o'-t megtaláltam. |
Lásd még: array_search()!
A key() a belső tömbmutató által pillanatnyilag kijelölt elem kulcsával tér vissza.
Példa 1. key() példa
|
Ez a függvény úgy rendezi az array tömböt a kulcsai alapján, hogy az indexek megtartják kapcsolatukat a hozzájuk rendelt tömb elemeivel. Főként asszociatív tömbök rendezéséhez használatos.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A rendezést befolyásolja a sort_flags paraméter, részletesebben lásd a sort() függvénynél!
Lásd még: asort(), arsort(), ksort() sort(), natsort() és rsort()!
Ez a függvény úgy rendezi az array tömböt a kulcsai alapján, hogy az indexek megtartják kapcsolatukat a hozzájuk rendelt tömb elemeivel. Főként asszociatív tömbök rendezéséhez használatos.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A rendezést befolyásolja a sort_flags paraméter, részletesebben lásd a sort() függvénynél!
Lásd még: asort(), arsort(), krsort(), uksort(), sort(), natsort() és rsort().
Megjegyzés: A második paraméter PHP 4-ben használható.
Az array()-hoz hasonlóan a list() sem valódi függvény, hanem nyelvi építőelem. A list() a több változó érték-hozzárendelésére szolgál egy műveleten belül.
Megjegyzés: A list() csak numerikus indexelésű tömbökön működik helyesen, és akkor is csak, ha az indexelés 0-tól kezdődik.
Példa 1. list() példák
|
Példa 2. Példa a list() használatára
|
| Figyelem |
A list() az értékek hozzárendelését jobbról kezdi el. Sima változók esetében ez nem okoz különösebb fejtörést, de tömbelemek esetén általában az az elvárt viselkedés, hogy az elemek felsorolásuk sorrendjében kerülnek a tömbbe, azaz a list() paraméterlistájában elfoglalt helyüknek megfelelően balról - jobbra haladva. Ez azonban nem így van, a hozzárendelés jobbról balra halad: |
array(3) {
[2]=>
string(8) "koffein"
[1]=>
string(5) "fekete"
[0]=>
string(6) "kávé"
} |
(PHP 4, PHP 5)
natcasesort -- tömböt rendez a "natural order" (természetes sorrend) algoritmus alapján kis-nagybetűk figyelembevétele nélkülEz a függvény olyan rendező algoritmust valósít meg, amely az alfanumerikus sztringeket úgy rendezi, ahogy azt egy ember tenné. Ezt az eljárást nevezik "natural ordering"-nek - természetes rendezésnek.
A natcasesort() függvény a natsort() olyan változata, amely érzéketlen a kis- és nagybetűk különbségére. Lásd a natsort() függvényt a reguláris és a természetes rendezési algortimusok közötti különbségért!
Részletesebb leírásért lásd: Martin Pool Natural Order String Comparison c. oldalát!
Lásd még: sort(), natsort(), strnatcmp() és strnatcasecmp()!
Ez a függvény olyan rendező algoritmust valósít meg, amely az alfanumerikus sztringeket úgy rendezi, ahogy azt egy ember tenné. Ezt az eljárást nevezik "natural ordering"-nek - természetes rendezésnek. A sort() függvény reguláris rendezési algortimusa és eközötti különbséget szemlélteti a következő példa:
Ez a példa a következőt írja ki:
Hagyományos rendezés
Array
(
[0] => img1.png
[1] => img10.png
[2] => img12.png
[3] => img2.png
)
Természetes rendezés
Array
(
[3] => img1.png
[2] => img2.png
[1] => img10.png
[0] => img12.png
) |
Megjegyzés: Az index - érték párosítások megőrzésére az usort($tomb, 'strnatcmp') forma alkalmazása javasolt.
Lásd még: natcasesort(), strnatcmp() és strnatcasecmp()!
Visszaadja belső tömbmutató poziciója utáni elem értékét, vagy FALSE-ot, ha nincs következő elem.
A next() a current()-hoz hasonlóan viselkedik egy különbséggel. A belső tömbmutatót egy hellyel előbbre állítja, mielött visszadná az elem értékét. Ez azt jelenti, hogy a mostani pozició után következő értékkel tér vissza, és a belső tömbmutatót is eggyel előre lépteti. Ha a belső tömbmutató az elemlista végére ér, akkor a next() FALSE-ot ad vissza.
| Figyelem |
Ha a tömb üres elemeket is tartalmaz, akkor ezeknél az elemeknél a függvény ugyanúgy FALSE-szal tér vissza. Üres elemeket tartalmazó tömb bejárásához nézd meg az each() függvényt! |
Példa 1. Példa a next() és társainak haszálatára
|
Visszaadja belső tömbmutató pozíciója előtti tömbelem értékét, vagy FALSE-ot ha nincs következő elem.
| Figyelem |
Ha a tömb üres elemeket is tartalmaz, akkor ezeknél az elemeknél a függvény ugyanúgy FALSE-szal tér vissza. Üres elemeket tartalmazó tömb bejárásához nézd meg az each() függvényt! |
A prev() a next()-hez hasonlóan működik, kivéve hogy a tömbmutatót visszafelé lépteti nem pedig előre.
Példa 1. Példa a prev() és társainak haszálatára
|
A range() a low és high közé eső elemekből alkotott tömbbel tér vissza. Ha low nagyobb, mint high, akkor a sorozat high-tól indul low felé.
Megjegyzés: A 4.1.0 verziót megelőzően a range() függvény csak a növekvő egészszámokból álló tömböt tudott generálni. A karakteres tartomány és a csökkenő sorrendű elemek támogatása a 4.1.0 verziótól létezik.
Példa 2. csökkenő és a karakteres tartományok szimulációja
// array_reverse használható arra, hogy megfordítsa a tömböt foreach(array_reverse(range(0,9)) as $szam) { echo $szam; } # array_map() és chr() használható arra, hogy számokból karaktereket alkosson foreach(array_map('chr', range(ord('a'),ord('z'))) as $karakter) { echo $karakter; }
Lásd még a shuffle() függvényt további példákért!
A reset() visszaállítja az array tömb belső tömbmutatóját az első elemre.
reset() a tömb első elemével tér vissza.
Ez a függvény fordított sorrendben rendezi át a tömböt: a legnagyobbtól a legkisebb felé.
Megjegyzés: This function assigns new keys for the elements in array. It will remove any existing keys you may have assigned, rather than just reordering the keys.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A gyümölcsök az abc szerint fordított sorrendben vannak rendezve.
A rendezést befolyásolja a sort_flags paraméter, részletesebben lásd a sort() függvénynél!
Lásd még: arsort(), asort(), ksort(), krsort(), sort() és usort()!
Ez a függvény véletlenszerűen összekeveri a tömb elemeit.
Megjegyzés: This function assigns new keys for the elements in array. It will remove any existing keys you may have assigned, rather than just reordering the keys.
Megjegyzés: A 4.2.0 változattól kezdődően nincs már szükség a srand() vagy az mt_srand() függvény meghívására, a PHP maga megteszi ezt automatikusan.
Lásd még: arsort(), asort(), ksort(), rsort(), sort() és usort().
Ez a függvény egy tömb elemeit rendezi sorba a legkisebbtől haladva a legnagyobb felé - azaz növekvő sorrendben.
Ez a példa a következőt írja ki:
gyumolcsok[0] = alma gyumolcsok[1] = banán gyumolcsok[2] = citrom gyumolcsok[3] = narancs |
A gyümölcsök az abc sorrendben vannak rendezve.
A rendezést befolyásolja a sort_flags paraméter, amelynek a következő értékei lehetnek:
(a rendezést befolyásoló jelzők)
SORT_REGULAR - az elemeket hagyományosan hasonlítja össze
SORT_NUMERIC - az elemeket számokként hasonlítja össze
SORT_STRING - az elemeket szövegként hasonlítja össze
Lásd még: arsort(), asort(), ksort(), natsort(), natcasesort(), rsort(), usort(), array_multisort() és uksort()!
Megjegyzés: A második paraméter PHP 4-től használható.
(PHP 3 >= 3.0.4, PHP 4, PHP 5)
uasort -- tömböt rendez egy felhasználó összehasonlító függvénnyel megtartva az indextársítástEz a függvény úgy rendez egy tömböt, hogy megtartja az indexek és az értékek közti relációt. Főleg akkor használatos, amikor az asszociatív tömböket rendezzünk, ahol az elemek sorrendje fontos. Az összehasonlítást végző függvényt a felhasználó határozza meg.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: További példákért lásd a usort() és uksort() példáit, hogyan kell felhasználói függvényeket használni!
Lásd még: usort(), uksort(), sort(), asort(), arsort(), ksort() és rsort()!
(PHP 3 >= 3.0.4, PHP 4, PHP 5)
uksort -- tömböt rendez kulcsai alapján egy felhasználó összehasonlító függvénnyelEz a függvény egy felhasználói függvénnyel átrendezi a tömböt a kulcsok szerint. Akkor használjuk ezt a függvényt, ha a rendezendő tömböt nem szokványos feltétel alapján akarjuk rendezni,
Ez a példa a következőt írja ki:
20: húsz 10: tíz 4: négy 3: három |
Megjegyzés: A függvény neve helyett egy tömböt is átadhatsz, ami egy objektum referenciát és egy metódus nevet kell tartalmazzon.
Lásd még: usort(), uasort(), sort(), asort(), arsort(), ksort(), natsort() és rsort()!
(PHP 3 >= 3.0.3, PHP 4, PHP 5)
usort -- tömböt rendez elemértékei alapján egy felhasználó összehasonlító függvénnyelEz a függvény a cmp_function paraméterben megadott nevű felhasználói függvénnyel rendezi az array tömb elemeit. Ha a rendezendő tömböt nem szokványos feltétel alapján akarjuk rendezni, akkor használjuk ezt a függvényt.
Az összehasonlító függvénynek 0-nál kisebb vagy nagyobb ill. 0 értéket kell visszaadnia, ha az első elem kisebb vagy nagyobb a másodiknál, ill. ha egyenlők.
Megjegyzés: Ha két elem egyenlő, sorrendjük a rendezett tömbben nem definiált. A 4.0.6-os verzióig a felhasználói függvény ezen elemek eredeti sorrendjét meg tudta őrizni. A PHP 4.1.0-ban bevezetett új rendezőalgoritmus erre már nem nyújt lehetőséget, mivel nincs rá hatékony módszer.
Ez a példa a következőt írja ki:
0: 6 1: 5 2: 3 3: 2 4: 1 |
Megjegyzés: Ebben az egyszerű esetben nyilvánvalóan jobb választás az rsort() függvény használata.
Példa 2. Az usort() használata több dimenziós tömbökön
|
Több dimenziós tömbökre alkalmazva $a és $b az első indexre mutató referenciákat fog tartalmazni.
Ez a példa a következőt írja ki:
$gyumolcsok[0]: alma $gyumolcsok[1]: citrom $gyumolcsok[2]: szőlő |
Megjegyzés: A függvény neve helyett egy tömböt is átadhatsz, ami egy objektum referenciát és egy metódus nevet kell tartalmazzon.
Példa 3. Objektum tagfüggvényének (metódus) használata az usort()-tal
|
Ez a példa a következőt írja ki:
b c d |
| Figyelem |
Néhány C könyvtárban (mint például a Solaris rendszerekben) a gyorsrendezés alapjául szolgáló függvény a PHP összeomlását okozhatja, ha az összehasonlító függvény nem következetes értéket ad vissza. |
Lásd még: uasort(), uksort(), sort(), asort(), arsort(),ksort(), natsort() és rsort()!
Az aspell() függvények ellenőrzik egy szó helyesírását és javaslatokat kínálnak fel.
Megjegyzés: Az aspell csak a nagyon régi (a .27.* verzióig) aspell könyvtárakkal működik együtt. Ez a modul sem és az aspell könyvtár azon verziói sem támogatottak a továbbiakban. Ha helyesírásellenőrzési funkciókat szeretnél használni a PHP-ban, használd a pspell könyvtárat. Az a pspell könyvtárat használja, és képes az újabb aspell verzókkal együttműködni.
A függvényekhez aspell könyvár szükséges, amely beszerezhető a http://aspell.sourceforge.net/ címen.
(PHP 3 >= 3.0.7, PHP 4 <= 4.2.3)
aspell_check_raw -- Ellenőriz egy szót kis- és nagybetűk cseréje illetve a szöveg trimmelése nélkül [ellenjavallt]Az aspell_check_raw() ellenőrzi egy szó helyesírását anélkül, hogy manipulálná (megváltoztatná a kis- és nagybetűket vagy levágná a stringet), és TRUE-t ad vissza, ha a helyesírás jó, egyébként FALSE-ot.
Az aspell_check() ellenőrzi egy szó helyesírását és TRUE-t ad vissza, ha a helyesírás jó, egyébként FALSE-ot.
Az aspell_new() megnyit egy új szótárt, és visszaadja a szótárkapcsolat azonosítóját, amely a többi aspell függvényben használható. Hiba esetén FALSE-szal tér vissza.
(PHP 3 >= 3.0.7, PHP 4 <= 4.2.3)
aspell_suggest -- Egy szó helyesírására tesz javaslatot [ellenjavallt]Ha tetszőleges pontosságú matematikai műveleteket szeretnél végezni, a PHP a Binary Calculator Mathematics (BCMath) függvényeket kínálja erre a célra. Ezek a függvények tetszőleges méretben és pontossággal tudnak számokat ábrázolni karaktersorozatok felhasználásával.
A PHP 4.0.4-es változatától felfele a libbcmath a PHP forrásfa szerves részét képezi. Nincs tehát szükség külső függvénykönyvtár telepítéséhez, ha ezeket a függvényeket hadrendbe szeretnénk állítani.
These functions are only available if PHP was configured with --enable-bcmath. In PHP 3, these functions are only available if PHP was not configured with --disable-bcmath.
A PHP Windows-os változata beépített támogatással rendelkezik eme kiterjesztéshez. Nincs szükség semmilyen kiterjesztés betöltésére, hogy az itt felsorolt függvényeket használhasd.
Az alábbi függvények viselkedése befolyásolható a php.ini segítségével.
További részletekért és a PHP_INI_* konstansok definícióiért lásd: G Függelék.
A témába vágó konfigurációs direktívák rövid leírása
Hozzáadja a left_operand-ot a right_operand-hoz, és visszatér az összeget tartalmazó stringgel. Az elhagyható scale paraméter határozza meg az eredményben a tizedes pont utáni számjegyek számát.
Összehasonlítja a left_operand-ot a right_operand-al, és az eredményt egészként visszaadja. Az elhagyható scale paraméter beállítja a tizedes pont utáni számjegyek számát, amely felhasználásra kerül az összehasonlításban. A visszatérési érték 0, ha a két operandus egyenlő. Ha a left_operand nagyobb a right_operand-nál, az eredmény +1, de ha a left_operand kisebb nála, az eredmény -1.
Elosztja a left_operand-ot a right_operand-al, és visszaadja az eredményt. Az elhagyható scale paraméter beállítja az eredményben a tizedespont utáni számjegyek számát. Ennek alapértéke 0.
Kiszámítja a left_operand-nak a modulus-sal történő osztás utáni maradékát.
Összeszorozza a left_operand-ot a right_operand-dal, és visszaadja az eredményt. Az elhagyható scale paraméter határozza meg az eredményben a tizedespont utáni számjegyek számát.
Kiszámítja x szám y. hatványát. Az elhagyható scale paraméter beállítja az eredményben a tizedes pont utáni számjegyek számát.
Use the fast-exponentiation method to raise x to the power y with respect to the modulus modulus. The optional scale can be used to set the number of digits after the decimal place in the result.
Megjegyzés: Because this method uses the modulus operation, non-natural numbers may give unexpected results. A natural number is any positive non-zero integer.
The following two statements are functionally identical. The bcpowmod() version however, executes in less time and can accept larger parameters.
(PHP 3, PHP 4, PHP 5)
bcscale -- Beállítja az alapértelmezett skálázási értéket az összes BCMath matematikai függvény részéreEz a függvény beállítja a skálázási értékét minden bc matematikai függvény részére, így nem kell mindig explicit módon megadni a scale paramétert, csak ha szükséges. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Visszaadja az operand négyzetgyökét. Az elhagyható scale paraméter beállítja az eredményben a tizedes pont utáni számjegyek számát.
Kivonja a right_operand-ot a left_operand-ból, és visszaadja az eredményt tartalmazó string-et. Az elhagyható scale paraméter beállítja az eredményben a tizedes pont utáni számjegyek számát.
| Figyelem |
Ez a kiterjesztés KÍSÉRLETI JELLEGGEL MŰKÖDIK. Ez azt jelenti, hogy minden itt dokumentált működés, beleértve a függvények nevét, működését vagy bármi más, amit a kiterjesztés kapcsán leírtunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a kiterjesztést csak a saját felelősségedre használd! |
Bcompiler was written for several reasons:
| To encode entire script in a proprietary PHP application |
| To encode some classes and/or functions in a proprietary PHP application |
| To enable the production of php-gtk applications that could be used on client desktops, without the need for a php.exe. |
| To do the feasibility study for a PHP to C converter |
The second of these goals is achieved using the bcompiler_write_header(), bcompiler_write_class(), bcompiler_write_footer(), bcompiler_read(), and bcompiler_load() functions. The bytecode files can be written as either uncompressed or plain. The bcompiler_load() reads a bzip compressed bytecode file, which tends to be 1/3 of the size of the original file.
To create EXE type files, bcompiler has to be used with a modified sapi file or a version of PHP which has been compiled as a shared library. In this scenario, bcompiler reads the compressed bytecode from the end of the exe file.
bcompiler can improve performance by about 30% when used with uncompressed bytecodes only. But keep in mind that uncompressed bytecode can be up to 5 times larger than the original source code. Using bytecode compression can save your space, but decompression requires much more time than parsing a source. bcompiler also does not do any bytecode optimization, this could be added in the future...
In terms of code protection, it is safe to say that it would be impossible to recreate the exact source code that it was built from, and without the accompanying source code comments. It would effectively be useless to use the bcompiler bytecodes to recreate and modify a class. However it is possible to retrieve data from a bcompiled bytecode file - so don't put your private passwords or anything in it.
short installation note:
You need at least PHP 4.3. for the compression to work
To install on PHP 4.3 and later at the unix command prompt type pear install bcompiler
To install on Windows, until the binary package distribution mechanism is finished please search the archives of the pear-general mailing list for pre-built packages. (or send an email to it if you could not find a reference)
To install on older versions you need to make some slight changes to the build.
untar the bcompiler.tgz archive into php4/ext.(Get it directly from PECL http://pecl.php.net/get/bcompiler)
If the new directory is now called something like bcompiler-0.x, then you should rename it to bcompiler (except you only want to build it as self-contained php-module).
If you are using versions before PHP 4.3, the you will need to copy the Makefile.in.old to Makefile.in and config.m4.old to config.m4.
run phpize in ext/bcompiler
run ./buildconf in php4
run configure with --enable-bcompiler (and your other options)
make; make install
that's it.
If you have comments, bugfixes, enhancements or want to help developing this beast, you can drop me a mail at alan_k@php.net. Any help is very welcome.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Reads data from a bcompiler exe file and creates classes from the bytecodes.
Példa 1. bcompiler_load() example
|
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Megjegyzés: Please use include or require statements to parse bytecodes, it's more portable and convenient way than using this function.
Reads data from a bzcompressed file and creates classes from the bytecodes. Please note that this function won't execute script body code contained in the bytecode file.
Megjegyzés: This function has been removed from bcompiler and is no longer available as of bcompiler 0.5.
Reads the bytecodes of a class and calls back to a user function.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Megjegyzés: Please use include or require statements to parse bytecodes, it's more portable and convenient way than using this function.
Reads data from a open file handle and creates classes from the bytecodes. Please note that this function won't execute script body code contained in the bytecode file.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This reads the bytecodes from PHP for an existing class, and writes them to the open file handle, It does not perform dependency checking, so make sure you write the classes in an order that will not result in an 'undefined class' occurring when you load it.
Példa 1. bcompiler_write_class() example
|
See also bcompiler_write_header(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This function reads the bytecodes from PHP for an existing constant, and writes them to the open file handle.
See also bcompiler_write_header(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
An EXE (or self executable) file consists of 3 parts,
| The stub (executable code, e.g. a compiled C program) that loads PHP interpreter, bcompiler extension, stored Bytecodes and initiates a call for the specified function (e.g. main) or class method (e.g. main::main) |
| The Bytecodes (uncompressed only for the moment) |
| The bcompiler EXE footer |
To obtain a suitable stub you can compile php_embed-based stub phpe.c located in the examples/embed directory on bcompiler's CVS.
Példa 1. bcompiler_write_footer() example
|
See also bcompiler_write_header(), bcompiler_write_class(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This function complies specified source file into bytecodes, and writes them to the open file handle.
See also bcompiler_write_header(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Writes the single character \x00 to indicate End of compiled data.
See also bcompiler_write_header(), and bcompiler_write_header().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This reads the bytecodes from PHP for an existing function, and writes them to the open file handle. Order is not important, (eg. if function b uses function a, and you compile it like the example below, it will work perfectly OK).
See also bcompiler_write_header(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This function searches for all functions declared in the given file, and writes their correspondent bytecodes to the open file handle. Always remember to include/require the file you intend to compile.
See also bcompiler_write_header(), and bcompiler_write_footer().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Writes the header part of a bcompiler file. Optional second parameter can be used to write bytecode in a previously used format, so that you can use it with older versions of bcompiler.
See also bcompiler_write_file(), bcompiler_write_class(), bcompiler_write_function(), and bcompiler_write_footer().
A bzip2 (.bz2) tömörítési eljárással tömörített állományokat és a bennük levő fájlokat írja-olvassa.
Bzip2 support in PHP is not enabled by default. You will need to use the --with-bz2[=DIR] configuration option when compiling PHP to enable bzip2 support.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Ez a kiterjesztés egyetlen erőforrástípust definiál: egy fájlmutatót a feldolgozás alatt álló bz2 fájlokra.
A következő példaprogram megnyit egy próbafájlt, beleír egy rövid szöveget, majd kiírja a fájl tartalmát.
Példa 1. Rövid bzip2 példa
|
A fájl mutatónak egy létező és bzopen() függvénnyel sikeresen megnyitott fájlra kell mutatnia.
A bzcompress() függvény tömöríti a source paraméterben megadott stringet és visszatér ennek bzip2-vel tömörített változatával.
The string to compress.
Meghatározza a tömörítéshez használt blokkméretet, 1 és 9 között. A 9 adja a legjobb tömörítést, de ez a leginkább erőforrás-igényesebb is. A blocksize paraméter alpértelmezett értéke 4.
A tömörítési fázisok viselkedését befolyásolja, hogyan viselkedjenek a legrosszabb esetben, vagyis amikor temérdek ismétlődő adat követi egymást. Az értéke 0 és 250 között lehet, a 250 és a 0 különleges esetekben használatos, míg a 30 az alapértelmezett érték.
A workfactor paramétertől függetlenül, a generált kimenet ugyanaz lesz.
A bzdecompress() kitömöríti a megadott bzip2-vel tömörített adatot.
A kitömörítendő string.
Ha TRUE, akkor egy alternatív kitömörítő algoritmust használ, amelynek kevesebb a memóriaigénye (a maximális memóriaigénye körülbelül 2300K-ra esik), de nagyjából kétszer lassabban fut le.
Erről a lehetőségről a bzip2 dokumentációban tudhatsz meg többet.
A megadott fájlra vonatkozó bármilyen bzip2 művelet során fellépő hiba kódját adja meg.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
(PHP 4 >= 4.3.3, PHP 5)
bzerror -- A bzip2 hiba számát és a hibás sztringet egy tömbbe pakolva tér vissza.A megadott fájlra vonatkozó bármilyen bzip2 művelet során fellépő hiba kódját és a hozzá tartozó hibaüzenetet adja meg.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
Egy asszociatív tömb, amelynek az errno kulcsú eleme a hibakódot adja meg, az errstr pedig a hibaüzenetet.
A megadott fájlra vonatkozó bármilyen bzip2 művelet során fellépő hiba szövegét adja meg.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
Az összes pufferelt bzip2 adat írását kikényszeríti a bz fájl mutató (file pointer) számára.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
A bzopen() függvény megnyit egy bzip2 (.bz2 kiterjesztésű) fájlt olvasásra vagy írásra.
A megnyitandó fájl neve.
Hasonló, mint az fopen() függvény esetén ('r' olvasásra, 'w' írásra, stb.).
Ha a művelet sikertelen, akkor a bzopen() FALSE-szal (logikai HAMIS), egyébként az újonnan megnyitott fájlt szimbolizáló mutatóval (file pointer) tér vissza.
A bzread() olvas a megadott bzip2 fájlmutatóról.
Az olvasás akkor áll meg, ha length darab (kitömörített) bájtot beolvasott, vagy elérte a fájl végét, amelyik hamarabb bekövetkezik.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
Ha nincs megadva, akkor a bzread() 1024 (kitömörített) bájtot fog olvasni egyszerre.
A bzwrite() egy stringet a megadott bzip2 folyamba írja.
A fájlmutató. Érvényes kell legyen és egy bzopen()-el sikeresen megnyitott fájlra kell mutatnia.
A tömörítendő adat.
Ha meg van adva, akkor meg fog állni length darab (tömörítetlen) bájt kiírása után vagy amikor eléri a data végét, amelyik hamarabb bekkövetkezik.
A naptár kiterjesztés egy sereg függvényt bocsát rendelkezésre két naptárformátum egyszerű konvertálásához. A közvetítő vagy standard a Julián dátumon alapul. A Julián dátum egy elég korai dátumtól kezdődik, ezért nem akadhat vele probléma (kb i.e. 4000). A naptárrendszerek közti átszámoláshoz először Julián dátumra kell átszámítani a dátumot, majd a válaszott rendszerre. A Julián dátum nagyon különbözik a Julián-féle naptártól! (Erről további információkért látogass el a http://www.hermetic.ch/cal_stud/jdn.htm címre!) A naptárrendszerek információjához látogass el a http://www.boogle.com/info/cal-overview.html címre. Erről az oldalról néhány idézett kivonat megtalálható ebben az instrukcióban.
Ahhoz, hogy ezek a függvények működjenek az --enable-calendar kapcsolóval kell fordítani a PHP-t.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
The following constants are available since PHP 4.3.0 :
The following constants are available since PHP 5.0.0 :
(PHP 4 >= 4.1.0, PHP 5)
cal_days_in_month -- A megadott hónap napjainak számával tér vissza az adott naptár adott évébenEz a függvény a napok számával tér vissza, month hónapban, year évben, és a calendar naptár paraméterekben megadott értékek szerint.
Lásd még: jdtounix()!
Megjegyzés: Ez a függvény csak a PHP 4RC1 verzió óta használható.
(PHP 4 >= 4.1.0, PHP 5)
cal_from_jd -- Julián naptárból egy támogatott naptártípusba konvertál és további információkat szolgáltat(PHP 3 >= 3.0.9, PHP 4, PHP 5)
easter_date -- Kiszámolja egy adott év húsvétjának UNIX időbélyeggel megadott éjféli időpontjátVisszaadja az adott év húsvét éjfélt meghatározó UNIX időbélyeget (timestamp).
A PHP 4.3.0 változatától kezdődően az évszám paraméter megadása nem kötelező, elhagyása esetén az alapértelmezett évként a rendszeridő szerinti évszám lesz feldolgozva.
Figyelem: A függvény figyelmeztetést generál, ha az év kivül esik az UNIX dátum értelmezési tartományán (1970 előtti vagy 2037 utáni év).
Húsvét napját a Niceai Zsinat i.sz. 325-ben a tavaszi napéjegyenlőség napjára eső vagy az azutáni első telehold utáni vasárnapban határozta meg. A tavaszi napéjegyenlőséget mindig március 21-re fetételezték, hogy a számítást csökkentsék a telehold és az azt követő vasárnap meghatározására. Az algoritmust kb. 532-ben vezette be Dionyius Exiguus. A Julián naptár szerint (1753 előtti évekre vonatkoztatva) egy egyszerű 19 éves ciklust használtak a hold fázisainak nyomonkövetésére. A Clavius és Lillius által kigondolt, XIII. Gergely pápa által bevezetett és Nagy-Britanniában és gyarmatain 1752 szeptember 22.-én életbe lépett Gergely naptár szerint (1753 utáni évekre vonatkoztatva) két korrekciós tényezőt is belevettek a ciklus még pontosabbá tételéhez.
(A kód Simon Kershaw C programján alapul, <webmaster@ely.anglican.org>)
Lásd az easter_days() függvényt a húsvét kiszámításához 1970 elött és 2037 után.
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
easter_days -- Kiszámolja adott évben a március 21-től húsvétig terjedő napok számátKiszámolja adott évben a március 21-től húsvétig terjedő napok számát. Ha nem adod meg a year paramétert, az aktuális évet veszi alapul.
A PHP 4.3.0 változatától kezdődően az évszám paraméter megadása nem kötelező, elhagyása esetén az alapértelmezett évként a rendszeridő szerinti évszám lesz feldolgozva.
A számítási_módszer paraméter szintén a PHP 4.3.0 változatával került bevezetésre, és ezáltal lehetőség nyílik arra, hogy az 1582 - 1752 évekre vonatkozó, a Gregorián naptár szerinti számításokat elvégezhessük. Ehhez ebben a második paraméterben kell megadnunk a következő állandó értéket: CAL_EASTER_ROMAN. A további, itt megadható számítási módozatok állandóinak teljes listáját lásd itt : naptárkezeléssel kapcsolatos állandók.
Ez a függvény használható az easter_date() helyett, hogy kiszámolja a UNIX értelmezési tartományon kívülre eső évekre (i.sz. 1970 előtt vagy 2037 után) húsvét napját.
Húsvét napját a Niceai Zsinat i.sz. 325-ben a tavaszi napéjegyenlőség napjára eső vagy az azutáni első telehold utáni vasárnapban határozta meg. A tavaszi napéjegyenlőséget mindig március 21-re fetételezték, hogy a számítást csökkentsék a telehold és az azt követő vasárnap meghatározására. Az algoritmust kb. 532-ben vezette be Dionyius Exiguus. A Julián naptár szerint (1753 előtti évekre vonatkoztatva) egy egyszerű 19 éves ciklust használtak a hold fázisainak nyomonkövetésére. A Clavius és Lillius által kigondolt, XIII. Gergely pápa által bevezetett és Nagy-Britanniában és gyarmatain 1752 szeptember 22.-én életbe lépett Gergely naptár szerint (1753 utáni évekre vonatkoztatva) két korrekciós tényezőt is belevettek a ciklus még pontosabbá tételéhez.
(A kód Simon Kershaw C programján alapul, <webmaster@ely.anglican.org>)
Lásd még: easter_date()!
Francia köztársasági dátumból konvertál egy dátumot Julián dátumba.
Ezek a műveletek csak az 1-14 év közötti dátumokat számítják át. (Gergely naptár szerint 1792 szeptember 22. - 1806 szeptember 22.). Ez hosszabb intervallum, mint ameddig a naptárt használták.
A Gergely dátum értelmezési tartománya i.e. 4714 és i.sz. 9999 között van
Noha ez a szoftver a dátumokat i.e. 4714-ig képes kezelni, ilyen használata nem biztos, hogy értelmes adatot szolgáltat. A Gergely naptár 1582 október 15-től érvényes (vagy a Julián naptár szerint 1582 október 5-től). Néhány ország csak sokkal később fogadta el. Például Nagy-Britannia 1752-ben, a Szovjetúnió 1918-ban, Görögország 1923-ban ban tért át. A legtöbb európai ország a Julián naptárt használta a Gergely naptár előtt.
Visszaadja a hét egy napjának nevét. Sztringet vagy egészt adhat vissza a mode paramétertól függően.
Visszaadja a hónap nevét tartalmazó sztringet. A mode megadja a függvénynek, hogy milyen dátumtípusba konvertálja a Julián dátumot és milyen típusú hónapneveket adjon vissza.
Táblázat 1. Naptár módok
| mode | jelentés | értékek |
|---|---|---|
| 0 | Gergely naptár - rövidített | Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec |
| 1 | Gergely naptár | January, February, March, April, May, June, July, August, September, October, November, December |
| 2 | Julián naptár - rövidített | Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec |
| 3 | Julián naptár | January, February, March, April, May, June, July, August, September, October, November, December |
| 4 | Zsidó naptár | Tishri, Heshvan, Kislev, Tevet, Shevat, AdarI, AdarII, Nisan, Iyyar, Sivan, Tammuz, Av, Elul |
| 5 | Francia Köztársasági | Vendemiaire, Brumaire, Frimaire, Nivose, Pluviose, Ventose, Germinal, Floreal, Prairial, Messidor, Thermidor, Fructidor, Extra |
Julián dátumot konvertál Francia Köztársasági naptárba.
Julián dátumot konvertál Gergely dátumot leíró formába ("hónap/nap/év").
Julián dátumot konvertál Julián-féle naptári dátum formátumú sztringbe ("hónap/nap/év").
Ez a függvény egy Unix időbélyeget ad vissza a megadott jday Julián naphoz, vagy false-al tér vissza, ha a jday nincs a Unix időbélyeg értelmezési tartományán belül (Gergely naptár szerint 1970 és 2037 között, azaz 2440588 <= jday <= 2465342). Az időbélyeget helyi idő, és nem GMT szerint adja vissza.
Lásd még: unixtojd()!
Éretelmezési tartomány: Noha ez a szoftver a dátumokat i.e. 3761-ig képes kezelni (ez az első év), ilyen használata nem biztos, hogy értelmes adatot szolgáltat.
A zsidó naptárat évezredek óta használják, de korábban nem volt módszer egy hónap kezdetének meghatározására. Az új hónap mindig újholdkor kezdődött.
A Julián dátum értelmezési tartománya i.e. 4713 és i.sz. 9999 között van
Noha ez a szoftver a dátumokat i.e. 4713-ig képes kezelni, ilyen használata nem biztos, hogy értelmes adatot szolgáltat. A Julián naptárt i.e. 46-ban alkották, de teljes egészében csak i.sz. 8-ban vagy csak a IV. században lett bevezetve. Hasonlóan az év kezdete kultúráról kultúrára változott nem mindenhol fogadták el a januárt az első hónapnak.
Visszaadja a Unix timestamp-hez (1970 január 1. óta eltelt másodpercek), vagy a mai naphoz tartozó Julián dátumot, ha nincs megadott timestamp paraméter.
Lásd még: jdtounix()!
Megjegyzés: Ez a függvény csak a PHP 4RC1 verzió óta használható.
Ezek a függvények a CCVS API használatát teszik lehetővé, amik a CCVS közvetlen használatát biztosítják a PHP szriptek számára. A CCVS a RedHat megoldása a köztes pontra ("middle-man") a bankkártyák feldolgozásában. Ez lehetőséget ad a bankkártyák kiegyenlítési eljárásainak kezelésére egy *nix rendszer és egy modem segítségével. E modul segítéségével közvetlenül kezelheted a bankkártyákat a CCVS rendszer segítségével. Az alább olvasható referencia megmutatja, hogyan.
Ahhoz, hogy bekapcsold a PHP CCVS támogatását, először ellenőrizd a CCVS telepítési könyvtáradat. Utána a PHP fordításakor add meg a configure-nak a --with-ccvs paramétert. Ha a CCVS telepítési könyvtár megadása nélkül használod ezt a paramétert, a PHP az alapbeállítású CCVS elérési utat veszi alapul (/usr/local/ccvs). Ha a CCVS nem a hagyományos könyvtárban található, a --with-ccvs=$ccvs_eleresi_ut megoldást használd, ahol a $ccvs_eleresi_ut a CCVS telepítési könyvtára. Fontos megjegyezni, hogy a CCVS támogatáshoz elengedhetetlen, hogy a $ccvs_eleresi_ut/lib és a $ccvs_eleresi_ut/include létezik, és a cv_api.h magtalálható az include könyvtárban, a libccvs.a pedig a lib könyvtárban.
Ráadásul egy ccvsd a PHP-vel megegyező beállításokkal kell, hogy fusson. Úgyszintén meg kell győződnöd arról is, hogy a PHP processek ugyanazzal a userid-vel futnak, amivel a CCVS-t telepítetted. Ha például a CCVS-t a 'ccvs' user-rel telepítetted, a PHP processek a 'ccvs' felhasználói név alatt kell, hogy fussanak.
A CCVS-ről további információ található a ??? címen.
Ez a dokumentáció még fejlesztések előtt áll. Addig is a Radhat által fenntartott, kicsit aktualitását vesztett, de hasznos dokumentációját tudjuk ajánlani a http://www.redhat.com/docs/manuals/ccvs/ címen.
A CCVS fejlesztését a Red Hat már nem végzi, és nincsenek tervek a további folytatásra. Azoknak, akik helyettesítő terméket keresnek, a Main Street Softworks MCVE termékét ajánljuk, mint lehetséges helyettesítőt. Hasonló a felépítése, és dokumentált PHP támogatással rendelkezik.
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
(4.0.2 - 4.2.3 only)
ccvs_command -- Egy konkrét protokollal végrehajtható parancs futtatása, amit az általános CCVS API nem tud lekezelni
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
(4.0.2 - 4.2.3 only)
ccvs_lookup -- Egy megadott típusú elem megkeresése a megadott számú adatbázisban
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
Ezek a függvények PHP osztályokról és objektumpéldányokról adnak információkat, mint például: az objektum osztályának nevét (típusát), a tagváltozóit másnéven tulajdonságait, és metódusait is. Ezekkel a függvényekkel egy objektumnak nem csak az osztály-tagságát lehet megállapítani, hanem a származását is, azaz, melyik osztályt kiterjesztése az adott objektum osztály.
Ebben a példában definiálunk egy alap osztályt, és ennek egy kiterjesztését. Az alap osztály leír egy zöldséget (Zoldseg), meghatározva, hogy ehető-e vagy sem (eheto), és hogy milyen színű. Az alosztály a paraj (Paraj) hozzáad egy új metódust, hogy megfőzhesd, és egy másikat, hogy megállapítsd, hogy főtt-e.
Példa 1. classes.inc
|
Most két példányt létrehozunk a fenti osztályokból, és információkat írunk ki rólunk, beleértve az származásukat is. Definiálunk néhány hasznos függvényt, főleg azért, hogy ezeket az információkat szépen írjuk ki.
Példa 2. test_script.php
|
Fontos észrevenni, hogy a fenti példában a $soklevelu a Paraj objektum egy példánya, amely a Zoldseg egy alosztálya objektumnak, ezért a programunk utolsó része a következőt írja ki (szerencsére nincs probléma a névelőkkel :)
(PHP 4 >= 4.0.5, PHP 5)
call_user_method_array -- meghívja az adott objektum egy metódusát paramétertömbbel [ellenjavallt]| Figyelem |
A call_user_method_array() függvény PHP 4.1.0-től kezdve ellenjavallt. Helyette a call_user_func_array() függvényt kell használni a függvénynév paraméterében az array(&$obj, "method_name") szintaxissal. |
Meghívja a felhasználó által definiált obj objektum method_name paraméterben megnevezett metódusát. A metóusnak átadandó paramétereket a paramarr tömbből tölti fel sorjában.
Lásd még: call_user_func_array() és call_user_func().
(PHP 3 >= 3.0.3, PHP 4, PHP 5)
call_user_method -- Egy megadott objektumon belül meghív egy függvényt [ellenjavallt]| Figyelem |
A call_user_method() függvény PHP 4.1.0-től kezdve ellenjavallt. Helyette a call_user_func() függvényt kell használni a függvénynév paraméterében az array(&$obj, "method_name") szintaxissal. |
Meghívja a felhasználó által definiált obj objektum method_name paraméterben megnevezett metódusát. Az alábbi felhasználási példában definiálunk egy osztályt, létrehozunk egy objektumpéldányt, és a call_user_method() függvényt használjuk arra, hogy indirekten meghívjuk az objektum print_info metódusát.
<?php
class Orszag {
var $NEV;
var $TLD;
function Orszag($nev, $tld) {
$this->NEV = $nev;
$this->TLD = $tld;
}
function print_info($prestr="") {
echo $prestr."Ország: ".$this->NEV."\n";
echo $prestr."Top Level Domain: ".$this->TLD."\n";
}
}
$orsz = new Orszag("Peru","pe");
echo "* Az objektum metódusának közvetlen hívása\n";
$orsz->print_info();
echo "\n* Ugyanannak a közvetett meghívása\n";
call_user_method ("print_info", $orsz, "\t");
?> |
Lásd még: call_user_func()!
Ez a függvény TRUE-val tér vissza, ha a class_name osztály definiálva van, máskülönben FALSE-szal.
Ez a függvény a class_name által megadott osztály metódusainak nevei adja vissza egy tömbben.
Megjegyzés: PHP 4.0.6-tól kezdve, class_name osztálynév helyett közvetlenül az objektumot is át lehet adni paraméterként, például:
Példa 1. get_class_methods() példa
|
A fenti példa a következőt írja ki:
Lásd még: get_class_vars() és get_object_vars()!
Ez a függvény az osztály alaptulajdonságainak tömbjével tér vissza.
Megjegyzés: Inicializálatlan - kezdő érték nélküli - alaptulajdonságokat (tagváltozókat) nem ad vissza a get_class_vars().
Példa 1. get_class_vars() példa
|
A fenti példa a következőt írja ki:
Lásd még: get_class_methods() és get_object_vars()!
Ez a függvény visszaadja annak az osztálynak a nevét, amelynek az obj objektum egy példánya.
Megjegyzés: get_class() a felhasználó által definiált osztályok neveit mindig csupa kisbetűsként adja vissza, míg a kiterjesztésekben definiáltakat az eredeti elnevezésők szerint.
Lásd még: get_parent_class(), gettype() és is_subclass_of()!
Ez a függvény az aktuális szkriptben definiált osztályok neveit adja vissza egy tömbben.
Megjegyzés: A PHP 4.0.1pl2-ben, három extra osztályt ad vissza a függvény a tömb elején stdClass (ami a Zend/zend.c-ben definiált), OverloadedTestClass (ami az ext/standard/basic_functions.c-ben definiált) és Directory (ami az ext/standard/dir.c-ben definiált).
Attól függően, hogy milyen kiterjesztések vannak betöltve, egyéb osztályok is megjelenhetnek a listában. Ez azt jelenti, hogy saját osztályokat ilyen nevekkel már nem lehet definiálni. A függelékben vannak felsorolva az előre definiált osztályok hasonló című fejezetben.
This function returns an array of the names of the declared interfaces in the current script.
See also get_declared_classes().
Ez a függvény az obj paraméterben átadott objektumban definiált tulajdonságokat (tagváltozókat) és értékeiket adja vissza egy asszociatív tömbben. Az obj típusát jelentő osztályban deklarált, de kezdőérték nélküli tagváltozókat nem adja vissza a függvény.
Példa 1. get_object_vars() használata
|
Array
(
[x] => 1.233
[y] => 3.445
)
Array
(
[x] => 1.233
[y] => 3.445
[cimke] => pont #1
) |
Lásd még: get_class_methods() és get_class_vars()!
Ha obj objektum típusú, akkor visszaadja az obj példány "típusát" jelentő osztály szülőosztályának nevét.
Ha obj sztring típusú, akkor visszaadja az ilyen nevű osztály szülőosztályának nevét. Ez PHP 4.0.5-től kezdve használható.
Lásd még: get_class() és is_subclass_of()!
This function returns TRUE if the interface given by interface_name has been defined, FALSE otherwise.
interface_exists() will attempt to call __autoload by default, if you don't want interface_exists() to call __autoload, you can set the parameter autoload to FALSE.
See also class_exists().
(PHP 4 >= 4.2.0, PHP 5)
is_a -- megvizsgálja, hogy az objektum leszármazottja vagy tagja-e egy osztálynakEz a függvény TRUE-t ad vissza, ha az object a class_name osztály vagy annak egy leszármazott osztályának példánya, egyébként FALSE-t ad vissza.
Lásd még: get_class(), get_parent_class() és is_subclass_of()!
(PHP 4, PHP 5)
is_subclass_of -- megviszgálja, hogy egy objektum egy megadott osztálynak egy alosztályához tartozik-eEz a függvény TRUE-val tér vissza, ha az obj objektum olyan osztálynak egy példánya, amely alosztálya/leszármazottja a class_name nevű osztálynak. Másik esetben FALSE-t ad vissza.
Megjegyzés: A PHP 5.0.3-as változatától kezdve az object paramétert szövegesen is megadhatod (az osztály nevét).
Példa 1. is_subclass_of() példa
A fenti példa a következő kimenetet adja:
|
Lásd még: get_class() és get_parent_class()!
Ez a függvény TRUE-val tér vissza, ha a method_name nevű metódus definiálva van az adott object objektumhoz, különben FALSE-szal.
This function checks if the given property exists in the specified class (and if it is accessible from the current scope).
Megjegyzés: As opposed with isset(), property_exists() returns TRUE even if the property has the value NULL.
A string with the class name or an object of the class to test for
The name of the property
Returns TRUE if the property exists, FALSE if it doesn't exist or NULL in case of an error.
Példa 1. A property_exists() example
|
These functions allow the dynamic manipulation of PHP classes, at runtime.
Megjegyzés: This extension has been replaced by runkit, which is not limited to class manipulation but has function manipulation, as well.
Ez a PECL kiterjesztés a PHP alapterjesztésében nem szerepel.
További információk, mint például új kiadások, letöltés, forrásállományok, karbantartók, CHANGELOG találhatóak itt: http://pecl.php.net/package/classkit.
Ezen PECL kiterjesztés DLL állományát letöltheted a PHP Letöltések, vagy a http://snaps.php.net/ címről.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
Megjegyzés: This function cannot be used to manipulate the currently running (or chained) method.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Példa 1. classkit_import() example
A fenti példa a következő kimenetet adja:
|
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The class to which this method will be added
The name of the method to add
Comma-delimited list of arguments for the newly-created method
The code to be evaluated when methodname is called
The type of method to create, can be CLASSKIT_ACC_PUBLIC, CLASSKIT_ACC_PROTECTED or CLASSKIT_ACC_PRIVATE
Megjegyzés: This parameter is only used as of PHP 5, because, prior to this, all methods were public.
Példa 1. classkit_method_add() example
A fenti példa a következő kimenetet adja:
|
| classkit_method_copy() |
| classkit_method_redefine() |
| classkit_method_remove() |
| classkit_method_rename() |
| create_function() |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Destination class for copied method
Destination method name
Source class of the method to copy
Name of the method to copy from the source class. If this parameter is omitted, the value of dMethod is assumed.
Példa 1. classkit_method_copy() example
A fenti példa a következő kimenetet adja:
|
| classkit_method_add() |
| classkit_method_redefine() |
| classkit_method_remove() |
| classkit_method_rename() |
Megjegyzés: This function cannot be used to manipulate the currently running (or chained) method.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The class in which to redefine the method
The name of the method to redefine
Comma-delimited list of arguments for the redefined method
The new code to be evaluated when methodname is called
The redefined method can be CLASSKIT_ACC_PUBLIC, CLASSKIT_ACC_PROTECTED or CLASSKIT_ACC_PRIVATE
Megjegyzés: This parameter is only used as of PHP 5, because, prior to this, all methods were public.
Példa 1. classkit_method_redefine() example
A fenti példa a következő kimenetet adja:
|
| classkit_method_add() |
| classkit_method_copy() |
| classkit_method_remove() |
| classkit_method_rename() |
Megjegyzés: This function cannot be used to manipulate the currently running (or chained) method.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The class in which to remove the method
The name of the method to remove
Példa 1. classkit_method_remove() example
A fenti példa a következő kimenetet adja:
|
| classkit_method_add() |
| classkit_method_copy() |
| classkit_method_redefine() |
| classkit_method_rename() |
Megjegyzés: This function cannot be used to manipulate the currently running (or chained) method.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The class in which to rename the method
The name of the method to rename
The new name to give to the renamed method
A ClibPDF segítségével PDF dokumentumokat lehet létrehozni PHP-vel. A ClibPDF funkcionalitásában és az API tekintetében is hasonló a PDFlib-hez.
Ezt a dokumentációt ajánlatos a ClibPDF kézikönyvvel együtt olvasni mivel az a függvényeket nagyobb részletességgel magyarázza.
Sok függvény az alap ClibPDF-ben, a PHP modulban, valamint a PDFlib-ben a ugyanazzal a névvel rendelkezik. Az összes függvény, kivéve a cpdf_open() első paramétereként a dokumentum kezelőjét (handler) kéri. Jelenleg ez a kezelőt a PHP belsőleg nem használja, mivel a ClibPDF nem támogatja több PDF dokumentum egyidejű létrehozását. Ezzel nagyon ne is próbálkozz, mert az eredményt nem lehet előre megjósolni. Nem tudható, hogy a többszálas környezetben ez milyen következnényekkel járna. A ClibPDF szerzője szerint ez változni fog a következő változatnál (az írás idején a jelenlegi verzió az 1.10). Ha mégis szükséged van erre a lehetőségre, használd a PDFlib modult.
A PDFlib-el szemben van egy nagy előnye a ClibPDF-nek. PDF doumentumokat tud létrehozni a memóriában ideiglenes fájlok használata nélkül. Lehetőséget ad továbbá arra, hogy koordinátákat adj át egy előre definiált mértékegységben. Ez egy nagyon jó lehetőség, de szimulálható a PDFlib pdf_translate() függvényével.
A legtöbb függvény egyszerűen használható. A legnehezebb rész valószínűleg egy nagyon egyszerű PDF létrehozása. A következő példa segíthet az elindulásban. Ez egy egy oldalas dokumentumot készít. Az oldal tartalmazza a "Times-Roman" szöveget egy 30 pont méretű körvonalas betűtípusssal. A szöveg aláhúzott.
Megjegyzés: Ez a kiterjesztés átkerült a PECL tárba és már nem terjesztik a PHP-vel együtt ettől a verziótól kezdve: PHP 5.1.0.
Megjegyzés: Ha olyan PDF előállítási lehetőségek érdekelnének, amelyhez nincs szükség külső, PHP-hez fordítandó függvénykönytárakra, nézd meg ezt az ide vonatkozó GYIK bejegyzést!
Ahhoz, hogy a ClibPDF függvényeit használatba vehesd, telepítened kell a ClibPDF csomagot. Ez elérhető a FastIO-nál, de ez üzleti célokra csak megvásárolt licensszel használható. A PHP megköveteli, hogy minimum 2-es változatú cpdflib-et használj.
To get these functions to work, you have to compile PHP with --with-cpdflib[=DIR]. DIR is the cpdflib install directory, defaults to /usr. In addition you can specify the jpeg library and the tiff library for ClibPDF to use. To do so add to your configure line the options --with-jpeg-dir[=DIR] --with-tiff-dir[=DIR].
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
Példa 1. Egyszerű ClibPDF példa
|
A PDFlib csomag egy összetettebb példát tartalmaz, amely egy oldalsorozatot állít elő egy analóg órával. Ez itt a ClibPDF kiterjesztést használó PHP-be konvertált változat:
Példa 2. pdfclock példa a PDFlib 2.0 csomagból
|
A cpdf_add_annotation() függvény egy megjegyzést helyez el a bal alsó sarkával az (llx, lly) koordinátájú pontban és jobb felső sarkával az (urx, ury) pontban. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
(PHP 3 >= 3.0.9, PHP 4, PHP 5 <= 5.0.4)
cpdf_add_outline -- Könyvjelzőt helyez el az aktuális oldalonA cpdf_add_outline() függvény a text szöveggel egy könyvjelzőt helyez el, amely az aktuális oldalra mutat.
A cpdf_arc() függvény ívet rajzol az (x_koor, y_koor) középpont köré radius sugárral, start kezdőszögtől end végszögig. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_circle().
A cpdf_begin_text() függvény egy szöveg szekciót kezd el. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad. Ennek a szövegrészletnek a cpdf_end_text() függvény meghívásával kell végződnie.
Lásd még: cpdf_end_text().
A cpdf_circle() függvény egy kört rajzol az (x_koor, y_koor) középpont köré radius sugárral. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_arc().
A cpdf_clip() függvény vágja az összes rajzot az aktuális alakzathoz. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_close() függvény bezárja a pdf dokumentumot. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad. Ajánlatos, hogy ez legyen az utolsó tevékenység a cpdf_finalize(), cpdf_output_buffer() és cpdf_save_to_file() függvények után.
Lásd még: cpdf_open().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_closepath_fill_stroke -- Bezárja, kitölti és körvonalazza az aktuális alakzatotA cpdf_closepath_fill_stroke() függvény bezárja, kitölti az aktuális alakzatot az aktuális színező színnel és kirajzolja azt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_closepath(), cpdf_stroke(), cpdf_fill(), cpdf_setgray_fill(), cpdf_setgray(), cpdf_setrgbcolor_fill(), cpdf_setrgbcolor().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_closepath_stroke -- Bezárja az alakzatot és körvonalat rajzol az alakzat menténA cpdf_closepath_stroke() függvény a cpdf_closepath() és a cpdf_stroke() függvények kombinációja. Törli az alakzatot. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_closepath() és cpdf_stroke().
A cpdf_closepath() lezárja az aktuális alakzatot. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_continue_text() függvény a text stringben megadott szöveget a következő sorba helyezi. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_show_xy(), cpdf_text(), cpdf_set_leading(), cpdf_set_text_pos().
A cpdf_curveto() függvény Bezier-görbét rajzol az aktuális pozícióból a (x3, y3) pontba, felhasználva az (x1, y1) és (x2, y2) pontokat, mint kontrollpontokat. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_moveto(), cpdf_rmoveto(), cpdf_rlineto(), cpdf_lineto().
A cpdf_end_text() függvény befejezi a szöveg szekciót amely a cpdf_begin_text() függvényel lett megkezdve. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_begin_text().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_fill_stroke -- Kitölti és körvonalazza az aktuális alakzatotA cpdf_fill_stroke() függvény kitölti az aktuális alakzat belsejét az aktuális színező színnel és kirajzolja azt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_closepath(), cpdf_stroke(), cpdf_fill(), cpdf_setgray_fill(), cpdf_setgray(), cpdf_setrgbcolor_fill() és cpdf_setrgbcolor().
A cpdf_fill() függvény kitölti az aktuális alakzat belsejét az aktuális színező szinnel. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_closepath(), cpdf_stroke(), cpdf_setgray_fill(), cpdf_setgray(), cpdf_setrgbcolor_fill(), cpdf_setrgbcolor().
A cpdf_finalize_page() függvény befejzi a page_number számú oldalt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Ez a függvény csak memóriafelszabadításra szolgál. A befejezett oldal kevesebb memóriát foglal el de tovább már nem módosítható.
Lásd még: cpdf_page_init().
A cpdf_finalize() függvény befejezi a dokumentumot. Ezután a cpdf_close()-t még mindenképpen meg kell hívni. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_close().
(PHP 4, PHP 5 <= 5.0.4)
cpdf_global_set_document_limits -- A pdf dokumentumra vonatkozó korlátozások beállítására szolgálA cpdf_global_set_document_limits() függvény számos dokumentummal kapcsolatos korlátozást állít. A függvényt a cpdf_open() függvény meghívása előtt kell meghívni, mert csak a függvényhívás után megnyitott dokumentumok korlátait állítja. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még a cpdf_open() függvényt!
A cpdf_import_jpeg() függvény megnyit egy, a file_name nevű fájlban tárolt képet. A képformátum kötelezően jpeg. A képet az aktuális oldal (x_koor, y_koor) koordinátájú pontjában helyezi el. A kép elforgatható angle fokkal. A gsave paraméter nullától eltérő értékbe állítandó, ha a függvényt szeretnénk korrekt működésre bírni.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_place_inline_image().
A cpdf_lineto() függvény vonalat rajzol az aktuális pozícióból az (x_koor, y_koor) koordinátájú pontba. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_moveto(), cpdf_rmoveto(), cpdf_curveto().
A cpdf_moveto() függvény beállítja az aktuális pozíciót az x_koor és y_koor koordinátájú pontra. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
A cpdf_newpath() új alakzatot kezd a pdf_document által megadott dokumentumban. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_open() függvény megnyit egy új pdf dokumentumot. Az első paraméter bekapcsolja a a dokumentum tömörítést, ha nem egyenlő NULLával. A második elhagyható paraméter beállítja azt a fájlt, amelybe a dokumentum kerül. Ha elhagyjuk, akkor a memóriában készül el és a cpdf_save_to_file() függvénnyel fájlba írható vagy a standard kimenetre küldhető a cpdf_output_buffer()-el.
Megjegyzés: A visszaadott értékre a ClibPDF későbbi verzióinál mint első paraméterre szükség lesz minden más pdf dokumentumba író függvény esetében.
A ClibPDF könyvtár a "-" filenevet a standard kimenet szinonímájaként veszi. Ha a PHP egy apache modulként van installálva, ez nem működik, mivel a ClibPDF kiiratási módja a starndard kimenetre nem működik együtt az apache-al. Megoldhatod a problémát, ha kihagyod a filenevet és a cpdf_output_buffer() függvényt használod a pdf kiiratásához.
Lásd még: cpdf_close() és cpdf_output_buffer().
(PHP 3 >= 3.0.9, PHP 4, PHP 5 <= 5.0.4)
cpdf_output_buffer -- A memóriapufferből kiiratja a pdf dokumentumotA cpdf_output_buffer() függvény a standard kimenetre küldi a pdf dokumentumot. Ehhez a dokumentumot a memóriában kell elkészíteni, azaz a cpdf_open() hívásnál nem kell filenév paramétert megadni. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_open().
A cpdf_page_init() függvény új oldalt kezd height magassággal és width szélességgel. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad. Az oldal száma page_number és orientációja orientation. Az orientation paraméter 0 álló és 1 fekvő irányítottság esetén. Az utolsó elhagyható unit paraméter beállítja a koordinátarendszer egységét. Értéke a postcript pontok száma egységenként. Mivel egy hüvelyk (inch) 72 ponttal egyenlő, a 72 érték felel meg egy hüvelyknek. Az alapértelmezés szintén a 72.
Lásd még: cpdf_set_current_page().
A cpdf_place_inline_image() függvény egy PHP képfüggvényekkel készített képet helyez el az oldalon az (x_coor, y_coor) pontban. A kép ezzel egyidőben méretezhető. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Megjegyzés: Ez a függvény csak abban az esetben áll rendelkezésre, ha a PHP a GD grafikus függvénykönyvtár 1.3-as változatával lett fordítva. Lásd még a GD kiterjesztés oldlát a telepítéssel kapcsolatban.
Lásd még: cpdf_import_jpeg().
A cpdf_rect() függvény egy téglalapot rajzol, amelynek jobb alsó sarkának koordinátája (x_koor, y_koor) pont. A téglalap szélessége widgth, magassága height. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Példa 1. Négyszög rajzolása
|
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_restore -- Visszaállítja a korábban elmentett környezetetA cpdf_restore() függvény visszaállítja a cpdf_save() függvénnyel elmentett környezetet. Ez úgy működik, mint a postscript grestore parancs. Nagyon hasznos, ha egy objektumot anélkül akarunk áthelyezni vagy elforgatni, hogy az más objektumokra is hatással legyen. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_save().
A cpdf_rlineto() függvény vonalat rajzol az aktuális pozícióból az (x_koor, y_koor) relatív koordinátájú ponthoz. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Az utolsó elhagyható paraméter megadja a hosszúsági egységet. Ha ez 0 vagy el van hagyva, az alapértelmezett érték az oldal számára meghatározott érték. Egyébként a koordinátákat postcript pontok szerint veszi figyelembe.
Lásd még: cpdf_moveto(), cpdf_rmoveto(), cpdf_curveto().
A cpdf_rmoveto() függvény beálítja az aktuális pontot az x_koor és y_koor relatív koordinátájú ponthoz. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Lásd még: cpdf_moveto().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
A cpdf_rotate() függvény beállítja az elforgatás szögét angle értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_save_to_file() függvény fájlba írja a pdf dokumentumot ha ez korábban a memóriában készült el. Nem szükséges, ha a pdf dokumentumot úgy nyitottad meg, hogy adtál filenév paramétert a cpdf_open()-nek. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_output_buffer() és cpdf_open().
A cpdf_save() függvény elmenti az aktuális környezetet. Ez úgy működik, mint a postscript gsave parancs. Nagyon hasznos, ha egy objektumot anélkül akarunk áthelyezni vagy elforgatni, hogy az más objektumokra is hatással legyen. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_restore().
A cpdf_scale() függvény beállítja a méretezési faktort mindkét irányban. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
A cpdf_set_char_spacing() függvény beállítja a karakterek közötti távolságot. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_set_word_spacing() és cpdf_set_leading().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_creator -- A pdf dokumentumban a létrehozó(creator) mezőt állítjaA cpdf_set_creator() függvény a pdf dokumentum szerző mezőjét állítja. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még cpdf_set_subject(), cpdf_set_title() és cpdf_set_keywords()!
A cpdf_set_current_page() függvény beállítja azt az oldalt, amelyre az összes további művelet vonatkozik. Egy oldal választható, ameddig nincs befejezve a cpdf_finalize_page()-al. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_finalize_page().
(PHP 4 >= 4.0.6, PHP 5 <= 5.0.4)
cpdf_set_font_directories -- Sets directories to search when using external fonts
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
(PHP 4 >= 4.0.6, PHP 5 <= 5.0.4)
cpdf_set_font_map_file -- Sets fontname to filename translation map when using external fonts
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_font -- Kiválaszja az aktuális betűtípust és méretetA cpdf_set_font() függvény beállítja az aktuális betűtípust, betűméretet és kódolást. Jelenleg csak a standard postscript betűtípusok támogatottak. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az utolsó encoding paraméter a következő értékeket veheti fel: "MacRomanEncoding", "MacExpertEncoding", "WinAnsiEncoding", és "NULL". "NULL" jelenti a betűtípus beépített kódolását. Lásd a ClibPDF Kézikönyvet további információért főleg az ázsiai fontok támogatását illetően.
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_horiz_scaling -- Beállítja a szöveg vízszintes méretezésétA cpdf_set_horiz_scaling() függvény beállítja a vízszintes méretezést a scale százalékra. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_keywords -- Beállítja a pdf dokumentum kulcsszavak mezőjétA cpdf_set_keywords() függvény beállítja a pdf dokumentum kulcsszavait. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_set_title(), cpdf_set_creator() és cpdf_set_subject().
A cpdf_set_leading() függvény beállítja a szövegsorok közötti távolságot. Ez a cpdf_continue_text() függvénnyel elhelyezett szövegnél használatos.
Lásd még: cpdf_continue_text().
(PHP 3 >= 3.0.9, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_page_animation -- Beállítja az oldalak közti átmeneti időtartamotA cpdf_set_page_animation() függvény beállítja az átmenetet két egymást követő oldal között. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A transition értéke lehet
| 0: nincs átmenet, |
| 1: két, a képernyőn végigseprő vonal fedi fel az új oldalt, |
| 2: több, a képernyőn végigseprő vonal fedi fel az új oldalt, |
| 3: egy négyzet fedi fel az új oldalt, |
| 4: egy, a képernyőn végigseprő vonal fedi fel az új oldalt, |
| 5: a régi oldal szétoszolva fedi fel az új oldalt, |
| 6: egy szétoszló effektus mozog az egyik képernyőszéltől a másikig, |
| 7: a régi oldal egyszerűen helyettesítődik az új oldallal (alapértelmezés) |
A duration értéke a képek közötti átmenet másodperceinek száma.
A cpdf_set_subject() függvény beállítja a pdf dokumentum tárgyát. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_set_title(), cpdf_set_creator() és cpdf_set_keywords().
A cpdf_set_text_matrix() függvény beállít egy mátrixot, amely leír egy, az aktuális betűtípusra alkalmazott transzformációt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_set_text_pos() függvény beállítja a szöveg pozícióját a következő cpdf_show() függvényhíváshoz. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Az utolsó elhagyható mode paraméter megadja a hosszúsági egységet. Ha ez 0 vagy el van hagyva, az alapértelmezett érték az oldal számára meghatározott érték. Egyébként a koordinátákat postcript pontok szerint veszi figyelembe.
Lásd még: cpdf_show() és cpdf_text().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_text_rendering -- Meghatározza hogyan legyen a szöveg kirajzolvaA cpdf_set_text_rendering() függvény meghatározza, hogy hogyan legyen egy szöveg kirajzolva. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A lehetséges értékek a rendermode paraméter részére: 0=szöveg kitöltés, 1=szöveg körvonala, 2=szöveg kitöltése és körvonala, 3=láthatatlan, 4=szövegkitöltés és kivágó alakzat készítése, 5=szöveg körvonala és kivágó alakzat készítése, 6=szöveg kitöltése, körvonala és kivágó alakzat készítése, 7=csak kivágó alakzat készítése.
A cpdf_set_text_rise() függvény beállítja a szöveg emelkedését a value egységre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_title -- A pdf dokumentumban a cím(title) mezőt állítjaA cpdf_set_title() függvény a pdf dokumentum cím mezőjét állítja.
Lásd még a cpdf_set_subject(), cpdf_set_creator() és cpdf_set_keywords() függvényeket!
(PHP 3 >= 3.0.9, PHP 4, PHP 5 <= 5.0.4)
cpdf_set_viewer_preferences -- How to show the document in the viewer
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
A cpdf_set_word_spacing() függvény beállítja a szavak közötti távolságot. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_set_char_spacing() és cpdf_set_leading().
A cpdf_setdash() függvény beállítja a szaggatott vonalminta white fehér és black fekete egységre. Ha mindkettő 0, akkor sima vonalat állít be. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_setflat() függvény beállítja a simaságot egy 0 - 100 közötti értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_setgray_fill() függvény beállítja az aktuális szürke értéket egy alakzat kitöltése céljából. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_setrgbcolor_fill().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_setgray_stroke -- Szürke értékre állítja a körvonalrajzoló színtA cpdf_setgray_stroke() függvény az adott szürke értékre állítja az aktuális rajzoló színt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_setrgbcolor_stroke().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_setgray -- Szürke értékre állítja a rajzoló és kitöltő színtA cpdf_setgray_stroke() függvény az adott szürke színre állítja a rajzoló és kitöltő színt. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_setrgbcolor_stroke(), cpdf_setrgbcolor_fill().
A cpdf_setlinecap() függvény beállítja a vonalcsúcs paramétert 0 - 2 közötti értékre. 0 = metszett, 1 = kerek, 2 = csapott négyszög. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_setlinejoin() függvény beállítja a vonalcsatlakozási paramétert 0 - 2 érték közé. 0 = hegyes, 1 = kerek, 2 = tompa. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_setlinewidth() függvény beállítja a vonalvastagságot a width értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
A cpdf_setmiterlimit() függvény beállítja a hegyesszög határának értékét 1-nél nagyobb vagy egyenlő értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_setrgbcolor_fill -- Rgb színértékre állítja be a kitöltő színtA cpdf_setrgbcolor_fill() függvény beállítja az aktuális rgb értéket egy alakzat kitöltése céljából. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: A színösszetevőket 0.0 és 1.0 közti lebegőpontos értékként kell megadni. (tehát a feketét a (0.0, 0.0, 0.0,) szimbolizálja, míg a fehéret az (1.0, 1.0, 1.0)).
Lásd még: cpdf_setrgbcolor_stroke() és cpdf_setrgbcolor().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_setrgbcolor_stroke -- Rgb színértékre állítja be a körvonalrajzoló színtA cpdf_setrgbcolor_stroke() függvény beállítja az aktuális rajzolószínt az adott rgb szín értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: A színösszetevőket 0.0 és 1.0 közti lebegőpontos értékként kell megadni. (tehát a feketét a (0.0, 0.0, 0.0,) szimbolizálja, míg a fehéret az (1.0, 1.0, 1.0)).
Lásd még: cpdf_setrgbcolor_fill() és cpdf_setrgbcolor().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_setrgbcolor -- Rgb színértékre állítja be a körvonalrajzoló és kitöltő színtA cpdf_setrgbcolor_stroke() függvény beállítja az aktuális rajzoló és kitöltő színt a megadott rgb szín értékre. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: A színösszetevőket 0.0 és 1.0 közti lebegőpontos értékként kell megadni. (tehát a feketét a (0.0, 0.0, 0.0,) szimbolizálja, míg a fehéret az (1.0, 1.0, 1.0)).
Lásd még: cpdf_setrgbcolor_stroke() és cpdf_setrgbcolor_fill().
A cpdf_show_xy() függvény a text stringben megadott szöveget az (x_koor, y_koor). kordinátájú pontba helyezi. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Megjegyzés: A cpdf_show_xy() függvény megegyezik a cpdf_text() függvénnyel az elhagyható paraméterektől eltekintve.
Lásd még: cpdf_text().
A cpdf_show() függvény a text stringben levő szöveget az aktuális pozícióba helyezi. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_text(), cpdf_begin_text(), cpdf_end_text().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_stringwidth -- Visszaadja a szöveg szélességét az aktuális font alapjánA cpdf_stringwidth() függvény visszaadja a text szöveg szélességét. Előtte a betűtípust mindenképpen be kell állítani.
Lásd még: cpdf_set_font().
A cpdf_stroke() függvény egy vonalat húz az aktuális alakzat mentén. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Lásd még: cpdf_closepath(), cpdf_closepath_stroke().
A cpdf_text() függvény a text stringben megadott szöveget a (x_koor, y_koor). által meghatározott pontba helyezi. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
Az elhagyható orientation paraméter a szöveg elforgatása fokban.
Az alignmode elhagyható paraméter határozza meg a szöveg igazítását.
Lásd a ClibPDF dokumentációt a lehetséges értékekre vonatkozólag.
Lásd még: cpdf_show_xy().
(PHP 3 >= 3.0.8, PHP 4, PHP 5 <= 5.0.4)
cpdf_translate -- Beállítja a koordinátarendszer kezdőpontjátA cpdf_translate() függvény az kordinátarendszer kezdőpontját a (x_koor, y_koor) pontba helyezi. Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Az opcionális mode paraméter határozza meg az egységhosszt. Ha nincs megadva, vagy 0 van megadva értéknek, az oldal alapértelmezése lesz érvényben. Ellenkező esetben a koordináták postscript pontokban lesznek mérve, függetlenül az aktuális egységhossz beállítástól.
COM is an acronym for Component Object Model; it is an object orientated layer (and associated services) on top of DCE RPC (an open standard) and defines a common calling convention that enables code written in any language to call and interoperate with code written in any other language (provided those languages are COM aware). Not only can the code be written in any language, but it need not even be part of the same executable; the code can be loaded from a DLL, be found in another process running on the same machine, or, with DCOM (Distributed COM), be found in another process on a remote machine, all without your code even needing to know where a component resides.
There is a subset of COM known as OLE Automation which comprises a set of COM interfaces that allow loose binding to COM objects, so that they can be introspected and called at run-time without compile-time knowledge of how the object works. The PHP COM extension utilizes the OLE Automation interfaces to allow you to create and call compatible objects from your scripts. Technically speaking, this should really be called the "OLE Automation Extension for PHP", since not all COM objects are OLE compatible.
Now, why would or should you use COM? COM is one of the main ways to glue applications and components together on the Windows platform; using COM you can launch Microsoft Word, fill in a document template and save the result as a Word document and send it to a visitor of your web site. You can also use COM to perform administrative tasks for your network and to configure your IIS; these are just the most common uses; you can do much more with COM.
Starting with PHP 5, this extension (and this documentation) was rewritten from scratch and much of the old confusing and bogus cruft has be removed. Additionally, we support the instantiation and creation of .Net assemblies using the COM interoperability layer provided by Microsoft.
Please read this article for an overview of the changes in this extension in PHP 5.
COM functions are only available for the Windows version of PHP.
.Net support requires PHP 5 and the .Net runtime.
Semmilyen telepítés nem szükséges ezen függvények használatához, a PHP alapelemei.
A PHP Windows-os változata beépített támogatással rendelkezik eme kiterjesztéshez. Nincs szükség semmilyen kiterjesztés betöltésére, hogy az itt felsorolt függvényeket használhasd.
You are responsible for installing support for the various COM objects that you intend to use (such as MS Word); we don't and can't bundle all of those with PHP.
Starting with PHP 5, you may use PHP's own foreach statement to iterate over the contents of a standard COM/OLE IEnumVariant. In laymans terms, this means that you can use foreach in places where you would have used For Each in VB/ASP code.
Many COM objects expose their properties as arrays, or using array-style access. In PHP 4, you may use PHP array syntax to read/write such a property, but only a single dimension is allowed. If you want to read a multi-dimensional property, you could instead make the property access into a function call, with each parameter representing each dimension of the array access, but there is no way to write to such a property.
PHP 5 introduces the following new features to make your life easier:
Access multi-dimensional arrays, or COM properties that require multiple parameters using PHP array syntax. You can also write or set properties using this technique.
Iterate SafeArrays ("true" arrays) using the foreach 16 fejezet control structure. This works because SafeArrays include information about their size. If an array-style property implements IEnumVariant then you can also use foreach for that property too; take a look at For Each for more information on this topic.
This extension will throw instances of the class com_exception whenever there is a potentially fatal error reported by COM. All COM exceptions have a well-defined code property that corresponds to the HRESULT return value from the various COM operations. You may use this code to make programmatic decisions on how to handle the exception.
Az alábbi függvények viselkedése befolyásolható a php.ini segítségével.
Táblázat 1. Com configuration options
| Name | Default | Changeable | Changelog |
|---|---|---|---|
| com.allow_dcom | "0" | PHP_INI_SYSTEM | Available since PHP 4.0.5. |
| com.autoregister_typelib | "0" | PHP_INI_ALL | PHP_INI_SYSTEM in PHP 4. Available since PHP 4.1.0. |
| com.autoregister_verbose | "0" | PHP_INI_ALL | PHP_INI_SYSTEM in PHP 4. Available since PHP 4.1.0. |
| com.autoregister_casesensitive | "1" | PHP_INI_ALL | PHP_INI_SYSTEM in PHP 4. Available since PHP 4.1.0. |
| com.code_page | "" | PHP_INI_ALL | Available since PHP 5.0.0. |
| com.typelib_file | "" | PHP_INI_SYSTEM | Available since PHP 4.0.5. |
A témába vágó konfigurációs direktívák rövid leírása
When this is turned on, PHP will be allowed to operate as a D-COM (Distributed COM) client and will allow the PHP script to instantiate COM objects on a remote server.
When this is turned on, PHP will attempt to register constants from the typelibrary of objects that it instantiates, if those objects implement the interfaces required to obtain that information. The case sensitivity of the constants it registers is controlled by the com.autoregister_casesensitive configuration directive.
When this is turned on, any problems with loading a typelibrary during object instantiation will be reported using the PHP error mechanism. The default is off, which does not emit any indication if there was an error finding or loading the type library.
When this is turned on (the default), constants found in auto-loaded type libraries will be registered case sensitively. See com_load_typelib() for more details.
It controls the default character set code-page to use when passing strings to and from COM objects. If set to an empty string, PHP will assume that you want CP_ACP, which is the default system ANSI code page.
If the text in your scripts is encoded using a different encoding/character set by default, setting this directive will save you from having to pass the code page as a parameter to the COM class constructor. Please note that by using this directive (as with any PHP configuration directive), your PHP script becomes less portable; you should use the COM constructor parameter whenever possible.
Megjegyzés: This configuration directive was introduced with PHP 5.
When set, this should hold the path to a file that contains a list of typelibraries that should be loaded on startup. Each line of the file will be treated as the type library name and loaded as though you had called com_load_typelib(). The constants will be registered persistently, so that the library only needs to be loaded once. If a type library name ends with the string #cis or #case_insensitive, then the constants from that library will be registered case insensitively.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
For further information on COM read the COM specification or perhaps take a look at Don Box's Yet Another COM Library (YACL). You might find some additional useful information in our FAQ for 57 fejezet. If you're thinking of using MS Office applications on the server side, you should read the information here: Considerations for Server-Side Automation of Office.
The COM class allows you to instantiate an OLE compatible COM object and call its methods and access its properties.
COM class constructor. The parameters have the following meanings:
Can be a ProgID, Class ID or Moniker that names the component to load.
A ProgID is typically the application or DLL name, followed by a period, followed by the object name. e.g: Word.Application.
A Class ID is the UUID that uniquely identifies a given class.
A Moniker is a special form of naming, similar in concept to a URL scheme, that identifies a resource and specifies how it should be loaded. As an example, you could load up Word and get an object representing a word document by specifying the full path to the word document as the module name, or you can use LDAP: as a moniker to use the ADSI interface to LDAP.
The name of the DCOM server on which the component should be loaded and run. If NULL, the object is run using the default for the application. The default is typically to run it on the local machine, although the administrator might have configured the application to launch on a different machine.
If you specify a non-NULL value for server, PHP will refuse to load the object unless the com.allow_dcom configuration option is set to TRUE.
If server_name is an array, it should contain the following elements (case sensitive!). Note that they are all optional (although you need to specify both Username and Password together); if you omit the Server setting, the default server will be used (as mentioned above), and the instantiation of the object will not be affected by the com.allow_dcom directive.
Táblázat 1. DCOM server name
| server_name key | type | description |
|---|---|---|
| Server | string | The name of the server. |
| Username | string | The username to connect as. |
| Password | string | The password for Username. |
| Flags | integer | One or more of the following constants, logically OR'd together: CLSCTX_INPROC_SERVER, CLSCTX_INPROC_HANDLER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER, CLSCTX_SERVER and CLSCTX_ALL. The default value if not specified here is CLSCTX_SERVER if you also omit Server, or CLSCTX_REMOTE_SERVER if you do specify a server. You should consult the Microsoft documentation for CoCreateInstance for more information on the meaning of these constants; you will typically never have to use them. |
Specifies the codepage that is used to convert strings to unicode-strings and vice versa. The conversion is applied whenever a PHP string is passed as a parameter or returned from a method of this COM object. The code page is sticky in PHP 5, which means that it will propagate to objects and variants returned from the object.
Possible values are CP_ACP (use system default ANSI code page - the default if this parameter is omitted), CP_MACCP, CP_OEMCP, CP_SYMBOL, CP_THREAD_ACP (use codepage/locale set for the current executing thread), CP_UTF7 and CP_UTF8. You may also use the number for a given codepage; consult the Microsoft documentation for more details on codepages and their numeric values.
The returned object is an overloaded object, which means that PHP does not see any fixed methods as it does with regular classes; instead, any property or method accesses are passed through to COM.
Starting with PHP 5, PHP will automatically detect methods that accept parameters by reference, and will automatically convert regular PHP variables to a form that can be passed by reference. This means that you can call the method very naturally; you needn't go to any extra effort in your code.
In PHP 4, to pass parameters by reference you need to create an instance of the VARIANT class to wrap the byref parameters.
In PHP versions prior to 5, a number of not very pleasant hacks meant that the following method names were not passed through to COM and were handled directly by PHP. PHP 5 eliminates these things; read the details below to determine how to fix your scripts. These magic method names are case insensitive.
void COM::AddRef ( void )Artificially adds a reference count to the COM object.
| Figyelem |
You should never need to use this method. It exists as a logical complement to the Release() method below. |
Artificially removes a reference count from the COM object.
| Figyelem |
You should never need to use this method. Its existence in PHP is a bug designed to work around a bug that keeps COM objects running longer than they should. |
These pseudo methods are only available if com_isenum() returns TRUE, in which case, they hide any methods with the same names that might otherwise be provided by the COM object. These methods have all been eliminated in PHP 5, and you should use For Each XV, COM and .Net (Windows) Referencia instead.
variant COM::All ( void )Returns a variant representing a SafeArray that has 10 elements; each element will be an empty/null variant. This function was supposed to return an array containing all the elements from the iterator, but was never completed. Do not use.
variant COM::Next ( void )Returns a variant representing the next element available from the iterator, or FALSE when there are no more elements.
variant COM::Prev ( void )Returns a variant representing the previous element available from the iterator, or FALSE when there are no more elements.
void COM::Reset ( void )Rewinds the iterator back to the start.
Példa 1. COM example (1)
|
Példa 2. COM example (2)
|
The DOTNET class allows you to instantiate a class from a .Net assembly and call its methods and access its properties.
DOTNET class constructor. assembly_name specifies which assembly should be loaded, and class_name specifices which class in that assembly to instantiate. You may optionally specify a codepage to use for unicode string transformations; see the COM class for more details on code pages.
The returned object is an overloaded object, which means that PHP does not see any fixed methods as it does with regular classes; instead, any property or method accesses are passed through to COM and from there to DOTNET. In other words, the .Net object is mapped through the COM interoperability layer provided by the .Net runtime.
Once you have created a DOTNET object, PHP treats it identically to any other COM object; all the same rules apply.
Megjegyzés: You need to install the .Net runtime on your web server to take advantage of this feature.
The VARIANT is COM's equivalent of the PHP zval; it is a structure that can contain a value with a range of different possible types. The VARIANT class provided by the COM extension allows you to have more control over the way that PHP passes values to and from COM.
VARIANT class constructor. Parameters:
initial value. if omitted, or set to NULL an VT_EMPTY object is created.
specifies the content type of the VARIANT object. Possible values are one of the VT_XXX Előre definiált állandók XV, COM and .Net (Windows) Referencia .
In PHP versions prior to PHP 5, you could force PHP to pass a variant object by reference by OR'ing VT_BYREF with the type. In PHP 5, this hack is not supported; instead, PHP 5 can detect parameters passed by reference automatically; they do not even need to be passed as VARIANT objects.
Consult the MSDN library for additional information on the VARIANT type.
specifies the codepage that is used to convert strings to unicode. See the parameter of the same name in the COM class for more information.
PHP versions prior to PHP 5 define a number of (undocumented) virtual properties for instances of the VARIANT class; these properties have all been removed in PHP 5 in favour of its more natural syntax; these differences are best highlighted by example:
The reason for the change is that, internally, the COM extension sees VARIANT, COM and DOTNET classes as the same thing, and the design philosophy for these classes is that all property and member accesses are passed through to COM with no interference. The new syntax is more natural and less effort, and most of the removed virtual properties didn't make any sense in a PHP context in any case.
Megjegyzés: PHP 5 takes a much simpler approach to handling VARIANTs; when returning a value or fetching a variant property, the variant is converted to a PHP value only when there is a direct mapping between the types that would not result in a loss of information. In all other cases, the result is returned as an instance of the VARIANT class. You can force PHP to convert or evaluate the variant as a PHP native type by using a casting operator explicitly, or implicitly casting to a string by print()ing it. You may use the wide range of variant functions to perform arithmetic operations on variants without forcing a conversion or risking a loss of data.
See also variant_get_type().
Increases the components reference counter.
| Figyelem |
You should never need to use this function. |
Megjegyzés: This function has gone away in PHP 5.
Generates a Globally Unique Identifier (GUID) and returns it as a string. A GUID is generated in the same way as DCE UUID's, except that the Microsoft convention is to enclose a GUID in curly braces.
See also uuid_create() in the PECL uuid extension.
Instructs COM to sink events generated by comobject into the PHP object sinkobject. PHP will attempt to use the default dispinterface type specified by the typelibrary associated with comobject, but you may override this choice by setting sinkinterface to the name of the dispinterface that you want to use.
sinkobject should be an instance of a class with methods named after those of the desired dispinterface; you may use com_print_typeinfo() to help generate a template class for this purpose.
Be careful how you use this feature; if you are doing something similar to the example below, then it doesn't really make sense to run it in a web server context.
Példa 1. COM event sink example
|
See also com_print_typeinfo(), com_message_pump().
com_get_active_object() is similar to creating a new instance of a COM object, except that it will only return an object to your script if the object is already running. OLE applications use something known as the Running Object Table to allow well-known applications to be launched only once; this function exposes the COM library function GetActiveObject() to get a handle on a running instance.
progid must be either the ProgID or CLSID for the object that you want to access (for example Word.Application). code_page acts in precisely the same way that it does for the COM class.
If the requested object is running, it will be returned to your script just like any other COM object. Otherwise a com_exception will be raised. There are a variety of reasons why this function might fail, the most common being that the object is not already running. In that situation, the exception error code will be MK_E_UNAVAILABLE; you can use the getCode method of the exception object to check the exception code.
| Figyelem |
Using com_get_active_object() in a web server context is not always a smart idea. Most COM/OLE applications are not designed to handle more than one client concurrently, even (or especially!) Microsoft Office. You should read Considerations for Server-Side Automation of Office for more information on the general issues involved. |
Returns the value of the property of the COM component referenced by com_object. Returns FALSE on error.
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
com_invoke() invokes the method named function_name of the COM component referenced by com_object. com_invoke() returns FALSE on error, returns the function_name's return value on success. All the extra parameters function_parameters are passed to the method function_name.
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
(PHP 4 >= 4.1.0)
com_isenum -- Indicates if a COM object has an IEnumVariant interface for iteration [deprecated]Checks to see if a COM object can be enumerated using the Next() method hack. Returns TRUE if it can, FALSE if it cannot. See COM class for more details on these methods.
Megjegyzés: This function does not exist in PHP 5; use the more natural foreach statement to iterate over the contents of COM objects. See For Each XV, COM and .Net (Windows) Referencia for more details.
Loads a type-library and registers its constants in the engine, as though they were defined using define(). The case_insensitive behaves in the same way as the parameter with the same name in the define() function.
typelib_name can be one of the following:
The filename of a .tlb file or the executable module that contains the type library.
The type library GUID, followed by its version number, for example {00000200-0000-0010-8000-00AA006D2EA4},2,0.
The type library name, e.g. Microsoft OLE DB ActiveX Data Objects 1.0 Library.
Note that it is much more efficient to use the com.typelib_file configuration setting to pre-load and register the constants, although not so flexible.
If you have turned on com.autoregister_typelib , then PHP will attempt to automatically register the constants associated with a COM object when you instantiate it. This depends on the interfaces provided by the COM object itself, and may not always be possible.
Equivalent to using the new operator to create an instance of the COM class. You should do that instead of calling this function.
Megjegyzés: This function does not exist in PHP 5; use the COM class instead.
(PHP 4 >= 4.2.3, PHP 5)
com_message_pump -- Process COM messages, sleeping for up to timeoutms millisecondsThis function will sleep for up to timeoutms milliseconds, or until a message arrives in the queue. If a message or messages arrives before the timeout, they will be dispatched, and the function will return TRUE. If the timeout occurs and no messages were processed, the return value will be FALSE. If you do not specify a value for timeoutms, then 0 will be assumed. A 0 value means that no waiting will be performed; if there are messages pending they will be dispatched as before; if there are no messages pending, the function will return FALSE immediately without sleeping.
The purpose of this function is to route COM calls between apartments and handle various synchronization issues. This allows your script to wait efficiently for events to be triggered, while still handling other events or running other code in the background. You should use it in a loop, as demonstrated by the example in the com_event_sink() function, until you are finished using event bound COM objects.
(PHP 4 >= 4.2.3, PHP 5)
com_print_typeinfo -- Print out a PHP class definition for a dispatchable interfaceThe purpose of this function is to help generate a skeleton class for use as an event sink. You may also use it to generate a dump of any COM object, provided that it supports enough of the introspection interfaces, and that you know the name of the interface you want to display.
comobject should be either an instance of a COM object, or be the name of a typelibrary (which will be resolved according to the rules set out in com_load_typelib()). dispinterface is the name of an IDispatch descendant interface that you want to display. If wantsink is TRUE, the corresponding sink interface will be displayed instead.
See also com_event_sink(), com_load_typelib().
Ez a függény csupán csak egy álneve ennek: com_get().
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
Ez a függény csupán csak egy álneve ennek: com_set().
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
Ez a függény csupán csak egy álneve ennek: com_set().
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
Decreases the components reference counter.
| Figyelem |
You should never need to use this function. |
Megjegyzés: This function has gone away in PHP 5.
Sets the value of the property of the COM component referenced by com_object. Returns the newly set value if succeeded, FALSE on error.
Megjegyzés: This function does not exist in PHP 5; instead, you should use the regular and more natural OO syntax to access properties or call methods.
Returns the absolute value of val.
See also abs().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Adds left to right using the following rules (taken from the MSDN library), which correspond to those of Visual Basic:
Táblázat 1. Variant Addition Rules
| If | Then |
|---|---|
| Both expressions are of the string type | Concatenation |
| One expression is a string type and the other a character | Addition |
| One expression is numeric and the other is a string | Addition |
| Both expressions are numeric | Addition |
| Either expression is NULL | NULL is returned |
| Both expressions are empty | Integer subtype is returned |
See also variant_sub().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs a bitwise AND operation, according to the following truth table; note that this is slightly different from a regular AND operation.
Táblázat 1. Variant AND Rules
| If left is | If right is | then the result is |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | FALSE |
| TRUE | NULL | NULL |
| FALSE | TRUE | FALSE |
| FALSE | FALSE | FALSE |
| FALSE | NULL | FALSE |
| NULL | TRUE | NULL |
| NULL | FALSE | FALSE |
| NULL | NULL | NULL |
See also variant_or().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
This function makes a copy of variant and then performs a variant cast operation to force the copy to have the type given by type. type should be one of the VT_XXX constants.
This function wraps VariantChangeType() in the COM library; consult MSDN for more information.
See also variant_set_type().
Concatenates left with right and returns the result.
See also String operátorok 15 fejezet for the string concatenation operator; this function is notionally equivalent to $left . $right.
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Compares left with right and returns one of the following values:
Táblázat 1. Variant Comparision Results
| value | meaning |
|---|---|
| VARCMP_LT | left is less than right |
| VARCMP_EQ | left is equal to right |
| VARCMP_GT | left is greater than right |
| VARCMP_NULL | Either left, right or both are NULL |
This function will only compare scalar values, not arrays or variant records.
lcid is a valid Locale Identifier to use when comparing strings (this affects string collation). flags can be one or more of the following values OR'd together, and affects string comparisons:
Táblázat 2. Variant Comparision Flags
| value | meaning |
|---|---|
| NORM_IGNORECASE | Compare case insensitively |
| NORM_IGNORENONSPACE | Ignore nonspacing characters |
| NORM_IGNORESYMBOLS | Ignore symbols |
| NORM_IGNOREWIDTH | Ignore string width |
| NORM_IGNOREKANATYPE | Ignore Kana type |
| NORM_IGNOREKASHIDA | Ignore Arabic kashida characters |
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Converts timestamp from a unix timestamp value into a variant of type VT_DATE. This allows easier interopability between the unix-ish parts of PHP and COM.
See also variant_date_to_timestamp() for the inverse of this operation, mktime(), time().
Converts variant from a VT_DATE (or similar) value into a unix timestamp. This allows easier interopability between the unix-ish parts of PHP and COM.
See also variant_date_from_timestamp() for the inverse of this operation, date(), strftime().
Divides left by right and returns the result, subject to the following rules:
Táblázat 1. Variant Division Rules
| If | Then |
|---|---|
| Both expressions are of the string, date, character, boolean type | Double is returned |
| One expression is a string type and the other a character | Division and a double is returned |
| One expression is numeric and the other is a string | Division and a double is returned. |
| Both expressions are numeric | Division and a double is returned |
| Either expression is NULL | NULL is returned |
| right is empty and left is anything but empty | A com_exception with code DISP_E_DIVBYZERO is thrown |
| left is empty and right is anything but empty. | 0 as type double is returned |
| Both expressions are empty | A com_exception with code DISP_E_OVERFLOW is thrown |
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
If each bit in left is equal to the corresponding bit in right then TRUE is returned, otherwise FALSE is returned.
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
If variant is negative, then the first negative integer greater than or equal to the variant is returned, otherwise returns the integer portion of the value of variant.
See also variant_int(), variant_round(), floor(), ceil(), round().
| Figyelem |
This documentation is based on the MSDN documentation; it appears that this function is either the same as variant_int(), or that there is an error in the MSDN documentation. |
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
This function returns an integer value that indicates the type of variant, which can be an instance of COM, DOTNET or VARIANT classes. The return value can be compared to one of the VT_XXX constants.
The return value for COM and DOTNET objects will usually be VT_DISPATCH; the only reason this function works for those classes is because COM and DOTNET are descendants of VARIANT.
In PHP versions prior to 5, you could obtain this information from instances of the VARIANT class ONLY, by reading a fake type property. See the VARIANT class for more information on this.
Converts left and right to integer values, and then performs integer division according the following rules:
Táblázat 1. Variant Integer Division Rules
| If | Then |
|---|---|
| Both expressions are of the string, date, character, boolean type | Division and integer is returned |
| One expression is a string type and the other a character | Division |
| One expression is numeric and the other is a string | Division |
| Both expressions are numeric | Division |
| Either expression is NULL | NULL is returned |
| Both expressions are empty | A com_exception with code DISP_E_DIVBYZERO is thrown |
See also variant_div().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs a bitwise implication operation, according to the following truth table:
Táblázat 1. Variant Implication Table
| If left is | If right is | then the result is |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | TRUE |
| TRUE | NULL | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | TRUE |
| FALSE | NULL | TRUE |
| NULL | TRUE | TRUE |
| NULL | FALSE | NULL |
| NULL | NULL | NULL |
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
If variant is negative, then the first negative integer greater than or equal to the variant is returned, otherwise returns the integer portion of the value of variant.
See also variant_fix(), variant_round(), floor(), ceil(), round().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Divides left by right and returns the remainder.
See also variant_div(), variant_idiv().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Multiplies left by right and returns the result, subject to the following rules:
Táblázat 1. Variant Multiplication Rules
| If | Then |
|---|---|
| Both expressions are of the string, date, character, boolean type | Multiplication |
| One expression is a string type and the other a character | Multiplication |
| One expression is numeric and the other is a string | Multiplication |
| Both expressions are numeric | Multiplication |
| Either expression is NULL | NULL is returned |
| Both expressions are empty | Empty string is returned |
Boolean values are converted to -1 for FALSE and 0 for TRUE.
See also variant_div(), variant_idiv().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs logical negation of variant and returns the result.
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs bitwise not negation on variant and returns the result. If variant is NULL, the result will also be NULL.
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs a bitwise OR operation, according to the following truth table; note that this is slightly different from a regular OR operation.
Táblázat 1. Variant OR Rules
| If left is | If right is | then the result is |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | TRUE |
| TRUE | NULL | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | FALSE |
| FALSE | NULL | NULL |
| NULL | TRUE | TRUE |
| NULL | FALSE | NULL |
| NULL | NULL | NULL |
See also variant_and(), variant_xor().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Returns the result of left to the power of right.
See also pow().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Returns the value of variant rounded to decimals decimal places.
See also round().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
This function is similar to variant_cast() except that the variant is modified "in-place"; no new variant is created. The parameters for this function have identical meaning to those of variant_cast().
See also variant_cast().
Converts value to a variant and assigns it to the variant object; no new variant object is created, and the old value of variant is freed/released.
(PHP 5)
variant_sub -- subtracts the value of the right variant from the left variant value and returns the resultSubtracts right from left using the following rules:
Táblázat 1. Variant Subtraction Rules
| If | Then |
|---|---|
| Both expressions are of the string type | Subtraction |
| One expression is a string type and the other a character | Subtraction |
| One expression is numeric and the other is a string | Subtraction. |
| Both expressions are numeric | Subtraction |
| Either expression is NULL | NULL is returned |
| Both expressions are empty | Empty string is returned |
See also variant_add().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
Performs a logical exclusion, according to the following truth table:
Táblázat 1. Variant XOR Rules
| If left is | If right is | then the result is |
|---|---|---|
| TRUE | TRUE | FALSE |
| TRUE | FALSE | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | FALSE |
| NULL | NULL | NULL |
See also variant_and(), variant_or().
Megjegyzés: As with all the variant arithmetic functions, the parameters for this function can be either a PHP native type (integer, string, floating point, boolean or NULL), or an instance of a COM, VARIANT or DOTNET class. PHP native types will be converted to variants using the same rules as found in the constructor for the VARIANT class. COM and DOTNET objects will have the value of their default property taken and used as the variant value.
The variant arithmetic functions are wrappers around the similarly named functions in the COM library; for more information on these functions, consult the MSDN library. The PHP functions are named slightly differently; for example variant_add() in PHP corresponds to VarAdd() in the MSDN documentation.
These functions allow you to use the CrackLib library to test the 'strength' of a password. The 'strength' of a password is tested by that checks length, use of upper and lower case and checked against the specified CrackLib dictionary. CrackLib will also give helpful diagnostic messages that will help 'strengthen' the password.
Megjegyzés: Ez a kiterjesztés átkerült a PECL tárba és már nem terjesztik a PHP-vel együtt ettől a verziótól kezdve: PHP 5.0.0.
More information regarding CrackLib along with the library can be found at http://www.crypticide.com/users/alecm/.
Ez a PECL kiterjesztés a PHP alapterjesztésében nem szerepel. További információk, mint például új kiadások, letöltés, forrásállományok, karbantartók, CHANGELOG találhatóak itt: http://pecl.php.net/package/crack.
A PHP 4-es változatában ennek a PECL kiterjesztének a forrása az ext/ könyvtár alatt lelhető fel, vagy a fenti PECL link mögött. In order to use these functions you must compile PHP with Crack support by using the --with-crack[=DIR] configuration option.
Windows users will enable php_crack.dll inside of php.ini in order to use these functions. A PHP 4-es változatában ennek a kiterjesztésnek a DLL állománya (Windows esetében) az extensions/ könyvtár alatt található meg. Ezen PECL kiterjesztés DLL állományát letöltheted a PHP Letöltések, vagy a http://snaps.php.net/ címről.
Az alábbi függvények viselkedése befolyásolható a php.ini segítségével.
Táblázat 1. Crack configuration options
| Name | Default | Changeable | Changelog |
|---|---|---|---|
| crack.default_dictionary | NULL | PHP_INI_PERDIR | Available since PHP 4.0.5. |
This example shows how to open a CrackLib dictionary, test a given password, retrieve any diagnostic messages, and close the dictionary.
Példa 1. CrackLib example
|
Megjegyzés: If crack_check() returns TRUE, crack_getlastmessage() will return 'strong password'.
Performs an obscure check with the given password on the specified dictionary.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The crack lib dictionary. If not specified, the last opened dictionary is used.
The tested password.
crack_closedict() closes the specified dictionary identifier.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
crack_getlastmessage() returns the message from the last obscure check.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
crack_opendict() opens the specified CrackLib dictionary for use with crack_check().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Megjegyzés: Only one dictionary may be open at a time.
The functions provided by this extension check whether a character or string falls into a certain character class according to the current locale (see also setlocale()).
When called with an integer argument these functions behave exactly like their C counterparts from ctype.h. It means that if you pass an integer smaller than 256 it will use the ASCII value of it to see if it fits in the specified range (digits are in 0x30-0x39). If the number is between -128 and -1 inclusive then 256 will be added and the check will be done on that.
When called with a string argument they will check every character in the string and will only return TRUE if every character in the string matches the requested criteria. When called with an empty string the result will always be TRUE in PHP < 5.1 and FALSE since 5.1.
Passing anything else but a string or integer will return FALSE immediately.
It should be noted that ctype functions are always preferred over regular expressions, and even to some equivalent str_* and is_* functions. This is because of the fact that ctype uses a native C library and thus processes significantly faster.
Beginning with PHP 4.2.0 these functions are enabled by default. For older versions you have to configure and compile PHP with --enable-ctype. You can disable ctype support with --disable-ctype.
A PHP Windows-os változata beépített támogatással rendelkezik eme kiterjesztéshez. Nincs szükség semmilyen kiterjesztés betöltésére, hogy az itt felsorolt függvényeket használhasd.
Megjegyzés: Builtin support for ctype is available with PHP 4.3.0.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Checks if all of the characters in the provided string, text, are alphanumeric. In the standard C locale letters are just [A-Za-z] and the function is equivalent to preg_match('/^[a-z0-9]+$/iD', $text).
Returns TRUE if every character in text is either a letter or a digit, FALSE otherwise.
Példa 1. A ctype_alnum() example (using the default locale)
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are alphabetic. In the standard C locale letters are just [A-Za-z] and ctype_alpha() is equivalent to (ctype_upper($text) || ctype_lower($text)) if $text is just a single character, but other languages have letters that are considered neither upper nor lower case.
Returns TRUE if every character in text is a letter from the current locale, FALSE otherwise.
Példa 1. A ctype_alpha() example (using the default locale)
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are control characters. Control characters are e.g. line feed, tab, escape.
Returns TRUE if every character in text is a letter from the current locale, FALSE otherwise.
Példa 1. A ctype_cntrl() example
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are numerical.
Példa 1. A ctype_digit() example
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, creates visible output.
Returns TRUE if every character in text is printable and actually creates visible output (no white space), FALSE otherwise.
Példa 1. A ctype_graph() example
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are lowercase letters.
Returns TRUE if every character in text is a lowercase letter in the current locale.
Példa 1. A ctype_lower() example (using the default locale)
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are printable.
Returns TRUE if every character in text will actually create output (including blanks). Returns FALSE if text contains control characters or characters that do not have any output or control function at all.
Példa 1. A ctype_print() example
A fenti példa a következő kimenetet adja:
|
(PHP 4 >= 4.0.4, PHP 5)
ctype_punct -- Check for any printable character which is not whitespace or an alphanumeric characterChecks if all of the characters in the provided string, text, are punctuation character.
Returns TRUE if every character in text is printable, but neither letter, digit or blank, FALSE otherwise.
Példa 1. A ctype_punct() example
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, creates whitespace.
Returns TRUE if every character in text creates some sort of white space, FALSE otherwise. Besides the blank character this also includes tab, vertical tab, line feed, carriage return and form feed characters.
Példa 1. A ctype_space() example
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are uppercase characters.
Returns TRUE if every character in text is an uppercase letter in the current locale.
Példa 1. A ctype_upper() example (using the default locale)
A fenti példa a következő kimenetet adja:
|
Checks if all of the characters in the provided string, text, are hexadecimal 'digits'.
Returns TRUE if every character in text is a hexadecimal 'digit', that is a decimal digit or a character from [A-Fa-f] , FALSE otherwise.
Példa 1. A ctype_xdigit() example
A fenti példa a következő kimenetet adja:
|
PHP supports libcurl, a library created by Daniel Stenberg, that allows you to connect and communicate to many different types of servers with many different types of protocols. libcurl currently supports the http, https, ftp, gopher, telnet, dict, file, and ldap protocols. libcurl also supports HTTPS certificates, HTTP POST, HTTP PUT, FTP uploading (this can also be done with PHP's ftp extension), HTTP form based upload, proxies, cookies, and user+password authentication.
These functions have been added in PHP 4.0.2.
In order to use PHP's CURL functions you need to install the libcurl package. PHP requires that you use libcurl 7.0.2-beta or higher. In PHP 4.2.3, you will need libcurl version 7.9.0 or higher. From PHP 4.3.0, you will need a libcurl version that's 7.9.8 or higher. PHP 5.0.0 requires a libcurl version 7.10.5 or greater.
To use PHP's CURL support you must also compile PHP --with-curl[=DIR] where DIR is the location of the directory containing the lib and include directories. In the "include" directory there should be a folder named "curl" which should contain the easy.h and curl.h files. There should be a file named libcurl.a located in the "lib" directory. Beginning with PHP 4.3.0 you can configure PHP to use CURL for URL streams --with-curlwrappers.
Note to Win32 Users: In order to enable this module on a Windows environment, libeay32.dll and ssleay32.dll must be present in your PATH.
You don't need libcurl.dll from the CURL site.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
Available since PHP 5.1.0
Available since PHP 6.0.0
Available since PHP 5.1.0
Available since PHP 5.1.0
Available since PHP 5.1.0
Once you've compiled PHP with CURL support, you can begin using the CURL functions. The basic idea behind the CURL functions is that you initialize a CURL session using the curl_init(), then you can set all your options for the transfer via the curl_setopt(), then you can execute the session with the curl_exec() and then you finish off your session using the curl_close(). Here is an example that uses the CURL functions to fetch the example.com homepage into a file:
This function closes a CURL session and frees all resources. The CURL handle, ch, is also deleted.
Példa 1. Initializing a new CURL session and fetching a webpage
|
See also: curl_init().
This function copies a cURL handle, returning a new cURL handle with the same preferences.
Példa 1. Copying a cURL handle.
|
Returns the error number for the last cURL operation on the resource ch, or 0 (zero) if no error occurred.
See also curl_error() and Curl error codes.
(PHP 4 >= 4.0.3, PHP 5)
curl_error -- Return a string containing the last error for the current sessionReturns a clear text error message for the last cURL operation on the resource ch, or '' (the empty string) if no error occurred.
See also curl_errno() and Curl error codes.
This function should be called after you initialize a CURL session and all the options for the session are set. Its purpose is simply to execute the predefined CURL session (given by the ch).
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad. However, if the CURLOPT_RETURNTRANSFER option is set, it will return the result on success, FALSE on failure.
Példa 1. Initializing a new CURL session and fetching a webpage
|
Returns information about the last transfer, opt may be one of the following:
"CURLINFO_EFFECTIVE_URL" - Last effective URL
"CURLINFO_HTTP_CODE" - Last received HTTP code
"CURLINFO_FILETIME" - Remote time of the retrieved document, if -1 is returned the time of the document is unknown
"CURLINFO_TOTAL_TIME" - Total transaction time in seconds for last transfer
"CURLINFO_NAMELOOKUP_TIME" - Time in seconds until name resolving was complete
"CURLINFO_CONNECT_TIME" - Time in seconds it took to establish the connection
"CURLINFO_PRETRANSFER_TIME" - Time in seconds from start until just before file transfer begins
"CURLINFO_STARTTRANSFER_TIME" - Time in seconds until the first byte is about to be transferred
"CURLINFO_REDIRECT_TIME" - Time in seconds of all redirection steps before final transaction was started
"CURLINFO_SIZE_UPLOAD" - Total number of bytes uploaded
"CURLINFO_SIZE_DOWNLOAD" - Total number of bytes downloaded
"CURLINFO_SPEED_DOWNLOAD" - Average download speed
"CURLINFO_SPEED_UPLOAD" - Average upload speed
"CURLINFO_HEADER_SIZE" - Total size of all headers received
"CURLINFO_HEADER_OUT" - The request string sent. Available since PHP 6.0.0
"CURLINFO_REQUEST_SIZE" - Total size of issued requests, currently only for HTTP requests
"CURLINFO_SSL_VERIFYRESULT" - Result of SSL certification verification requested by setting CURLOPT_SSL_VERIFYPEER
"CURLINFO_CONTENT_LENGTH_DOWNLOAD" - content-length of download, read from Content-Length: field
"CURLINFO_CONTENT_LENGTH_UPLOAD" - Specified size of upload
"CURLINFO_CONTENT_TYPE" - Content-type of downloaded object, NULL indicates server did not send valid Content-Type: header
If called without the optional parameter opt an associative array is returned with the following array elements which correspond to opt options:
"url"
"content_type"
"http_code"
"header_size"
"request_size"
"filetime"
"ssl_verify_result"
"redirect_count"
"total_time"
"namelookup_time"
"connect_time"
"pretransfer_time"
"size_upload"
"size_download"
"speed_download"
"speed_upload"
"download_content_length"
"upload_content_length"
"starttransfer_time"
"redirect_time"
The curl_init() will initialize a new session and return a CURL handle for use with the curl_setopt(), curl_exec(), and curl_close() functions. If the optional url parameter is supplied then the CURLOPT_URL option will be set to the value of the parameter. You can manually set this using the curl_setopt() function.
Példa 1. Initializing a new CURL session and fetching a webpage
|
See also: curl_close(), curl_setopt()
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init(), curl_init(), and curl_multi_remove_handle().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init() and curl_close().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init() and curl_exec().
(PHP 5)
curl_multi_getcontent -- Return the content of a cURL handle if CURLOPT_RETURNTRANSFER is set| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_init() and curl_multi_close().
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init(), curl_init(), and curl_multi_add_handle().
(PHP 5)
curl_multi_select -- Get all the sockets associated with the cURL extension, which can then be "selected"| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
See also curl_multi_init().
Sets multiple options for a CURL session. This function is useful for setting a large amount of CURL options without repetitively calling curl_setopt().
The CURL session the options should be set for.
An array specifying which options to set and their values. The keys should be valid curl_setopt() constants or their integer equivalents.
Returns TRUE if all options were successfully set. If an option could not be successfully set, FALSE is immediately returned, ignoring any future options in the options array.
Példa 1. Initializing a new CURL session and fetching a webpage
|
Set an option for a CURL session identified by the ch parameter. option specifies which option to set, and value specifies the value for the option given.
value should be a bool for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_AUTOREFERER | TRUE to automatically set the Referer: field in requests where it follows a Location: redirect. | Available since PHP 5.1.0. |
| CURLOPT_BINARYTRANSFER | TRUE to return the raw output when CURLOPT_RETURNTRANSFER is used. | |
| CURLOPT_COOKIESESSION | TRUE to mark this as a new cookie "session". It will force libcurl to ignore all cookies it is about to load that are "session cookies" from the previous session. By default, libcurl always stores and loads all cookies, independent if they are session cookies are not. Session cookies are cookies without expiry date and they are meant to be alive and existing for this "session" only. | Available since PHP 5.1.0. |
| CURLOPT_CRLF | TRUE to convert Unix newlines to CRLF newlines on transfers. | |
| CURLOPT_DNS_USE_GLOBAL_CACHE | TRUE to use a global DNS cache. This option is not thread-safe and is enabled by default. | |
| CURLOPT_FAILONERROR | TRUE to fail silently if the HTTP code returned is greater than or equal to 400. The default behavior is to return the page normally, ignoring the code. | |
| CURLOPT_FILETIME | TRUE to attempt to retrieve the modification date of the remote document. You can then retrieve this value using the CURLINFO_FILETIME option with curl_getinfo(). | |
| CURLOPT_FOLLOWLOCATION | TRUE to follow any "Location: " header that the server sends as part of the HTTP header (note this is recursive, PHP will follow as many "Location: " headers that it is sent, unless CURLOPT_MAXREDIRS is set). | |
| CURLOPT_FORBID_REUSE | TRUE to force the connection to explicitly close when it has finished processing, and not be pooled for reuse. | |
| CURLOPT_FRESH_CONNECT | TRUE to force the use of a new connection instead of a cached one. | |
| CURLOPT_FTP_USE_EPRT | TRUE to use EPRT (and LPRT) when doing active FTP downloads. Use FALSE to disable EPRT and LPRT and use PORT only. | Added in PHP 5.0.0. |
| CURLOPT_FTP_USE_EPSV | TRUE to first try an EPSV command for FTP transfers before reverting back to PASV. Set to FALSE to disable EPSV. | |
| CURLOPT_FTPAPPEND | TRUE to append to the remote file instead of overwriting it. | |
| CURLOPT_FTPASCII | An alias of CURLOPT_TRANSFERTEXT. Use that instead. | |
| CURLOPT_FTPLISTONLY | TRUE to only list the names of an FTP directory. | |
| CURLOPT_HEADER | TRUE to include the header in the output. | |
| CURLOPT_HTTPGET | TRUE to reset the HTTP request method to GET. Since GET is the default, this is only necessary if the request method has been changed. | |
| CURLOPT_HTTPPROXYTUNNEL | TRUE to tunnel through a given HTTP proxy. | |
| CURLOPT_MUTE | TRUE to be completely silent with regards to the CURL functions. | |
| CURLOPT_NETRC | TRUE to scan your ~/.netrc file to find your username and password for the remote site that you're establishing a connection with. | |
| CURLOPT_NOBODY | TRUE to exclude the body from the output. | |
| CURLOPT_NOPROGRESS |
TRUE to disable the progress meter for CURL transfers.
| |
| CURLOPT_NOSIGNAL | TRUE to ignore any CURL function that causes a signal to be sent to the PHP process. This is turned on by default in multi-threaded SAPIs so timeout options can still be used. | Added in CURL 7.10 and PHP 5.0.0. |
| CURLOPT_POST | TRUE to do a regular HTTP POST. This POST is the normal application/x-www-form-urlencoded kind, most commonly used by HTML forms. | |
| CURLOPT_PUT | TRUE to HTTP PUT a file. The file to PUT must be set with CURLOPT_INFILE and CURLOPT_INFILESIZE. | |
| CURLOPT_RETURNTRANSFER | TRUE to return the transfer as a string of the return value of curl_exec() instead of outputting it out directly. | |
| CURLOPT_SSL_VERIFYPEER | FALSE to stop CURL from verifying the peer's certificate. Alternate certificates to verify against can be specified with the CURLOPT_CAINFO option or a certificate directory can be specified with the CURLOPT_CAPATH option. CURLOPT_SSL_VERIFYHOST may also need to be TRUE or FALSE if CURLOPT_SSL_VERIFYPEER is disabled (it defaults to 2). | TRUE by default as of CURL 7.10. Default bundle installed as of CURL 7.10. |
| CURLOPT_TRANSFERTEXT | TRUE to use ASCII mode for FTP transfers. For LDAP, it retrieves data in plain text instead of HTML. On Windows systems, it will not set STDOUT to binary mode. | |
| CURLOPT_UNRESTRICTED_AUTH | TRUE to keep sending the username and password when following locations (using CURLOPT_FOLLOWLOCATION), even when the hostname has changed. | Added in PHP 5.0.0. |
| CURLOPT_UPLOAD | TRUE to prepare for an upload. | |
| CURLOPT_VERBOSE | TRUE to output verbose information. Writes output to STDERR, or the file specified using CURLOPT_STDERR. |
value should be an integer for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_BUFFERSIZE | The size of the buffer to use for each read. There is no guarantee this request will be fulfilled, however. | Added in CURL 7.10 and PHP 5.0.0. |
| CURLOPT_CLOSEPOLICY | Either CURLCLOSEPOLICY_LEAST_RECENTLY_USED or CURLCLOSEPOLICY_OLDEST. There are three other CURLCLOSEPOLICY_ constants, but CURL does not support them yet. | |
| CURLOPT_CONNECTTIMEOUT | The number of seconds to wait whilst trying to connect. Use 0 to wait indefinitely. | |
| CURLOPT_DNS_CACHE_TIMEOUT | The number of seconds to keep DNS entries in memory. This option is set to 120 (2 minutes) by default. | |
| CURLOPT_FTPSSLAUTH | The FTP authentication method (when is activated): CURLFTPAUTH_SSL (try SSL first), CURLFTPAUTH_TLS (try TLS first), or CURLFTPAUTH_DEFAULT (let CURL decide). | Added in CURL 7.12.2 and PHP 5.1.0. |
| CURLOPT_HTTP_VERSION | CURL_HTTP_VERSION_NONE (default, lets CURL decide which version to use), CURL_HTTP_VERSION_1_0 (forces HTTP/1.0), or CURL_HTTP_VERSION_1_1 (forces HTTP/1.1). | |
| CURLOPT_HTTPAUTH |
The HTTP authentication method(s) to use. The options are: CURLAUTH_BASIC, CURLAUTH_DIGEST, CURLAUTH_GSSNEGOTIATE, CURLAUTH_NTLM, CURLAUTH_ANY, and CURLAUTH_ANYSAFE. You can use the bitwise | (or) operator to combine more than one method. If you do this, CURL will poll the server to see what methods it supports and pick the best one. CURLAUTH_ANY is an alias for CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. CURLAUTH_ANYSAFE is an alias for CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. | Added in PHP 5.0.0. |
| CURLOPT_INFILESIZE | The expected size, in bytes, of the file when uploading a file to a remote site. | |
| CURLOPT_LOW_SPEED_LIMIT | The transfer speed, in bytes per second, that the transfer should be below during CURLOPT_LOW_SPEED_TIME seconds for PHP to consider the transfer too slow and abort. | |
| CURLOPT_LOW_SPEED_TIME | The number of seconds the transfer should be below CURLOPT_LOW_SPEED_LIMIT for PHP to consider the transfer too slow and abort. | |
| CURLOPT_MAXCONNECTS | The maximum amount of persistent connections that are allowed. When the limit is reached, CURLOPT_CLOSEPOLICY is used to determine which connection to close. | |
| CURLOPT_MAXREDIRS | The maximum amount of HTTP redirections to follow. Use this option alongside CURLOPT_FOLLOWLOCATION. | |
| CURLOPT_PORT | An alternative port number to connect to. | |
| CURLOPT_PROXYAUTH | The HTTP authentication method(s) to use for the proxy connection. Use the same bitmasks as described in CURLOPT_HTTPAUTH. For proxy authentication, only CURLAUTH_BASIC and CURLAUTH_NTLM are currently supported. | Added in CURL 7.10.7 and PHP 5.1.0. |
| CURLOPT_PROXYPORT | The port number of the proxy to connect to. This port number can also be set in CURLOPT_PROXY. | Added in PHP 5.0.0. |
| CURLOPT_PROXYTYPE | Either CURLPROXY_HTTP (default) or CURLPROXY_SOCKS5. | Added in CURL 7.10 and PHP 5.0.0. |
| CURLOPT_RESUME_FROM | The offset, in bytes, to resume a transfer from. | |
| CURLOPT_SSL_VERIFYHOST | 1 to check the existence of a common name in the SSL peer certificate. 2 to check the existence of a common name and also verify that it matches the hostname provided. | |
| CURLOPT_SSLVERSION | The SSL version (2 or 3) to use. By default PHP will try to determine this itself, although in some cases you must set this manually. | |
| CURLOPT_TIMECONDITION | How CURLOPT_TIMEVALUE is treated. Use CURL_TIMECOND_IFMODSINCE to return the page only if it has been modified since the time specified in CURLOPT_TIMEVALUE. If it hasn't been modified, a "304 Not Modified" header will be returned assuming CURLOPT_HEADER is TRUE. Use CURL_TIMECOND_ISUNMODSINCE for the reverse effect. CURL_TIMECOND_IFMODSINCE is the default. | Added in PHP 5.1.0. |
| CURLOPT_TIMEOUT | The maximum number of seconds to allow CURL functions to execute. | |
| CURLOPT_TIMEVALUE | The time in seconds since January 1st, 1970. The time will be used by CURLOPT_TIMECONDITION. By default, CURL_TIMECOND_IFMODSINCE is used. |
value should be a string for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_CAINFO | The name of a file holding one or more certificates to verify the peer with. This only makes sense when used in combination with CURLOPT_SSL_VERIFYPEER. | |
| CURLOPT_CAPATH | A directory that holds multiple CA certificates. Use this option alongside CURLOPT_SSL_VERIFYPEER. | |
| CURLOPT_COOKIE | The contents of the "Set-Cookie: " header to be used in the HTTP request. | |
| CURLOPT_COOKIEFILE | The name of the file containing the cookie data. The cookie file can be in Netscape format, or just plain HTTP-style headers dumped into a file. | |
| CURLOPT_COOKIEJAR | The name of a file to save all internal cookies to when the connection closes. | |
| CURLOPT_CUSTOMREQUEST |
A custom request method to use instead of
"GET" or "HEAD" when doing
a HTTP request. This is useful for doing
"DELETE" or other, more obscure HTTP requests.
Valid values are things like "GET",
"POST", "CONNECT" and so on;
i.e. Do not enter a whole HTTP request line here. For instance,
entering "GET /index.html HTTP/1.0\r\n\r\n"
would be incorrect.
| |
| CURLOPT_EGBSOCKET | Like CURLOPT_RANDOM_FILE, except a filename to an Entropy Gathering Daemon socket. | |
| CURLOPT_ENCODING | The contents of the "Accept-Encoding: " header. This enables decoding of the response. Supported encodings are "identity", "deflate", and "gzip". If an empty string, "", is set, a header containing all supported encoding types is sent. | Added in CURL 7.10. |
| CURLOPT_FTPPORT | The value which will be used to get the IP address to use for the FTP "POST" instruction. The "POST" instruction tells the remote server to connect to our specified IP address. The string may be a plain IP address, a hostname, a network interface name (under Unix), or just a plain '-' to use the systems default IP address. | |
| CURLOPT_INTERFACE | The name of the outgoing network interface to use. This can be an interface name, an IP address or a host name. | |
| CURLOPT_KRB4LEVEL | The KRB4 (Kerberos 4) security level. Any of the following values (in order from least to most powerful) are valid: "clear", "safe", "confidential", "private".. If the string does not match one of these, "private" is used. Setting this option to NULL will disable KRB4 security. Currently KRB4 security only works with FTP transactions. | |
| CURLOPT_POSTFIELDS | The full data to post in a HTTP "POST" operation. | |
| CURLOPT_PROXY | The HTTP proxy to tunnel requests through. | |
| CURLOPT_PROXYUSERPWD | A username and password formatted as "[username]:[password]" to use for the connection to the proxy. | |
| CURLOPT_RANDOM_FILE | A filename to be used to seed the random number generator for SSL. | |
| CURLOPT_RANGE | Range(s) of data to retrieve in the format "X-Y" where X or Y are optional. HTTP transfers also support several intervals, separated with commas in the format "X-Y,N-M". | |
| CURLOPT_REFERER | The contents of the "Referer: " header to be used in a HTTP request. | |
| CURLOPT_SSL_CIPHER_LIST | A list of ciphers to use for SSL. For example, RC4-SHA and TLSv1 are valid cipher lists. | |
| CURLOPT_SSLCERT | The name of a file containing a PEM formatted certificate. | |
| CURLOPT_SSLCERTPASSWD | The password required to use the CURLOPT_SSLCERT certificate. | |
| CURLOPT_SSLCERTTYPE | The format of the certificate. Supported formats are "PEM" (default), "DER", and "ENG". | Added in CURL 7.9.3 and PHP 5.0.0. |
| CURLOPT_SSLENGINE | The identifier for the crypto engine of the private SSL key specified in CURLOPT_SSLKEY. | |
| CURLOPT_SSLENGINE_DEFAULT | The identifier for the crypto engine used for asymmetric crypto operations. | |
| CURLOPT_SSLKEY | The name of a file containing a private SSL key. | |
| CURLOPT_SSLKEYPASSWD |
The secret password needed to use the private SSL key specified in
CURLOPT_SSLKEY.
| |
| CURLOPT_SSLKEYTYPE | The key type of the private SSL key specified in CURLOPT_SSLKEY. Supported key types are "PEM" (default), "DER", and "ENG". | |
| CURLOPT_URL | The URL to fetch. You can also set this when initializing a session with curl_init(). | |
| CURLOPT_USERAGENT | The contents of the "User-Agent: " header to be used in a HTTP request. | |
| CURLOPT_USERPWD | A username and password formatted as "[username]:[password]" to use for the connection. |
value should be an array for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_HTTP200ALIASES | An array of HTTP 200 responses that will be treated as valid responses and not as errors. | Added in CURL 7.10.3 and PHP 5.0.0. |
| CURLOPT_HTTPHEADER | An array of HTTP header fields to set. | |
| CURLOPT_POSTQUOTE | An array of FTP commands to execute on the server after the FTP request has been performed. | |
| CURLOPT_QUOTE | An array of FTP commands to execute on the server prior to the FTP request. |
value should be a stream resource (using fopen(), for example) for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_FILE | The file that the transfer should be written to. The default is STDOUT (the browser window). | |
| CURLOPT_INFILE | The file that the transfer should be read from when uploading. | |
| CURLOPT_STDERR | An alternative location to output errors to instead of STDERR. | |
| CURLOPT_WRITEHEADER | The file that the header part of the transfer is written to. |
value should be a string that is the name of a valid callback function for the following values of the option parameter:
| Option | Set value to | Notes |
|---|---|---|
| CURLOPT_HEADERFUNCTION | The name of a callback function where the callback function takes two parameters. The first is the CURL resource, the second is a string with the header data to be written. Using this callback function, it becomes your responsibility to write the header data. Return the number of bytes written. | |
| CURLOPT_PASSWDFUNCTION | The name of a callback function where the callback function takes three parameters. The first is the CURL resource, the second is a string containing a password prompt, and the third is the maximum password length. Return the string containing the password. | |
| CURLOPT_READFUNCTION | The name of a callback function where the callback function takes two parameters. The first is the CURL resource, and the second is a string with the data to be read. Using this callback function, it becomes your responsibility to read the data. Return the number of bytes read. Return 0 to signal EOF. | |
| CURLOPT_WRITEFUNCTION | The name of a callback function where the callback function takes two parameters. The first is the CURL resource, and the second is a string with the data to be written. Using this callback function, it becomes your responsibility to write the data. Must return the exact number of bytes written or this will fail. |
Példa 1. Initializing a new CURL session and fetching a webpage
|
Ezek a függvények csak akkor használhatóak, ha az értelmező a --with-cybercash=[DIR]-rel lett lefordítva. Ezek a függvények a PHP 4-ben használhatóak.
A függvény egy asszociatív tömböt ad vissza az "errcode" elemmel, és ha az FALSE, akkor az "outbuff" (string), "outLth" (long) és "macbuff" (string) elemekkel.
This extension allows you to process credit cards transactions using Credit Mutuel CyberMUT system.
CyberMUT is a popular Web Payment Service in France, provided by the Credit Mutuel bank. If you are foreign in France, these functions will not be useful for you.
The use of these functions is almost identical to the original functions, except for the parameters of return for CreerFormulaireCM and CreerReponseCM, which are returned directly by functions PHP, whereas they had passed in reference in the original functions.
Megjegyzés: Ez a kiterjesztés nem működik Windows operációs rendszereken!
Megjegyzés: Ez a kiterjesztés átkerült a PECL tárba és már nem terjesztik a PHP-vel együtt ettől a verziótól kezdve: PHP 4.3.0
You will require the appropriate SDK for your platform, which may be sent to you after your CyberMUT's subscription (contact them via Web, or go to the nearest Credit Mutuel).
Megjegyzés: These functions only provide a link to CyberMUT SDK. Be sure to read the CyberMUT Developers Guide for full details of the required parameters.
cybermut_creerformulairecm() is used to generate the HTML form of request for payment.
(4.0.5 - 4.2.3 only, PECL)
cybermut_creerreponsecm -- Generate the delivery's acknowledgement of the payment's confirmationThe parameter is "OK" if the message of confirmation of the payment were correctly authenticated by cybermut_testmac(). Any other chain is regarded as an error message.
(4.0.5 - 4.2.3 only, PECL)
cybermut_testmac -- Make sure that there was no data diddling contained in the received message of confirmationcybermut_testmac() is used to make sure that there was no data diddling contained in the received message of confirmation. Pay attention to parameters code_return and text_free, which cannot be evaluated as is, because of the dash.
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
Megjegyzés: Ez a kiterjesztés nem működik Windows operációs rendszereken!
Megjegyzés: Ez a kiterjesztés átkerült a PECL tárba és már nem terjesztik a PHP-vel együtt ettől a verziótól kezdve: PHP 5.0.0.
To enable Cyrus IMAP support and to use these functions you have to compile PHP with the --with-cyrus option.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
Ezeket a függvényeket arra használhatod, hogy lekérdezd az dátumot és az időpontot a szerverről, ahol a PHP szkriptjeid futnak. Ezekkel a függvényekkel sokféleképpen formázhatod a dátumot és az időt.
Megjegyzés: Fontos megjegyezni, hogy ezek a függvények működése függ a szerver nyelvi beállításaitól. Mikor ezekkel a függvényekkel dolgozol ne felejtsd el figyelembe venni a szökőéveket és a nyári időszámítást ($datum += 7*24*60*60 helyett használd például a $datum = strtotime('+7 days', $datum) alakot).
Az itt leírt függvények használatához semmilyen külső függvénykönyvtár megléte nem szükségeltetik.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Visszatérési értéke TRUE, ha az argumentumban megadott dátum érvényes, egyébként FALSE. Egy dátum érvénes, ha:
az év 1 és 32767 között van
a hónap 1 és 12 között van
A day paraméter a month és a year paramétereknek megfelelő értéket vesz fel. (Szökőéveket természetesen helyesen kezeli)
Lásd még a mktime() és a strtotime() függvényt!
(PHP 5 >= 5.1.0RC1)
date_default_timezone_get -- Gets the default timezone used by all date/time functions in a scriptThis functions returns the default timezone, using the following "guess" order:
The timezone set using the date_default_timezone_set() function (if any)
The TZ environment variable (if non empty)
The date.timezone ini option (if set)
"magical" guess (if the operating system supports it)
If none of the above options succeeds, return UTC
(PHP 5 >= 5.1.0RC1)
date_default_timezone_set -- Sets the default timezone used by all date/time functions in a scriptdate_default_timezone_set() sets the default timezone used by all date/time functions.
Megjegyzés: Since PHP 5.1.0 (when the date/time functions were rewritten), every call to a date/time function will generate a E_NOTICE if the timezone isn't valid, and/or a E_STRICT message if using the system settings or the TZ environment variable.
Instead of using this function to set the default timezone in your script, you can also use the INI setting date.timezone to set the default timezone.
The timezone identifier, like UTC or Europe/Lisbon. The list of valid identifiers is available in the H Függelék.
This function returns FALSE if the timezone_identifier isn't valid, or TRUE otherwise.
A date_sunrise() függvény visszaadja a napkelte időpontját a megadott nap (timestamp-ként megadva) és hely szerint. A latitude, a longitude és a zenith paraméterek alapértelmezett értékei rendre a date.default_latitude, a date.default_longitude és a date.sunrise_zenith konfigurációs beállítások értékei.
A latitude paraméter az északi földrajzi szélességet jelöli. Ha déli értéket akarsz megadni, negatív számot adj meg. Ez a megjegyzés a longitude paraméterre is vonatkozik, amely alapesetben a keleti földrajzi hosszúságot jelenti.
A gmt_offset paraméter órákban jelöli az időzónát.
Táblázat 1. format konstansok
| konstans | leírás | példa |
|---|---|---|
| SUNFUNCS_RET_STRING | a napkelte időpontját string-ként adja vissza | 16:46 |
| SUNFUNCS_RET_DOUBLE | a napkelte időpontját float-ként adja vissz | 16.78243132 |
| SUNFUNCS_RET_TIMESTAMP | a napkelte időpontját integer-ként (időbélyegként) adja vissza | 1095034606 |
Példa 1. date_sunrise() példa
A fenti példa valami ilyesmi kimenetet ad:
|
Lásd még a date_sunset() függvényt.
A date_sunset() függvény visszaadja a napnyugta időpontját a megadott nap (timestamp-ként megadva) és hely szerint. A latitude, a longitude és a zenith paraméterek alapértelmezett értékei rendre a date.default_latitude, a date.default_longitude és a date.sunset_zenith konfigurációs beállítások értékei.
A latitude paraméter az északi földrajzi szélességet jelöli. Ha déli értéket akarsz megadni, negatív számot adj meg. Ez a megjegyzés a longitude paraméterre is vonatkozik, amely alapesetben a keleti földrajzi hosszúságot jelenti.
A gmt_offset paraméter órákban jelöli az időzónát.
Táblázat 1. format konstansok
| konstans | leírás | példa |
|---|---|---|
| SUNFUNCS_RET_STRING | a napnyugta időpontját string-ként adja vissza | 16:46 |
| SUNFUNCS_RET_DOUBLE | a napnyugta időpontját float-ként adja vissz | 16.78243132 |
| SUNFUNCS_RET_TIMESTAMP | a napnyugta időpontját integer-ként (időbélyegként) adja vissza | 1095034606 |
Példa 1. date_sunset() példa
A fenti példa valami ilyesmi kimenetet ad:
|
Lásd még a date_sunrise() függvényt.
Egy stringgel tér vissza, amely a formátumstring szerinti alakban tartalmazza a timestamp dátumot, ennek hiányában az aktuális helyi időt. Más szóval, a timestamp paraméter elhagyható és az alapértelmezett értéke a time() függvény értéke.
Megjegyzés: Az időpont érvényes időpontja tipikusan 1901 Dec. 13. 20:25:54 és 2038. Jan. 19. 03:14:07 közötti időpontot jelent (Greenwich-i időpont szerint) (Ezek a dátumok a legkisebb és a legnagyobb 32-bites egész szám által reprezentált dátumok). Windows-on ez az intervallum 1970.01.01 - 2038.01.19 .
Megjegyzés: Ha egy karakterlánc által leírt időpontból szeretnél időpontot gyártani, akkor használhatod a strtotime() függvényt. Ráadásul, néhány adatbázisnak van rá függvénye, hogy a belső időpont-ábrázolásukat "unix timestamp"-pé alakítják (a MySQL UNIX_TIMESTAMP függvénye ilyen).
Táblázat 1. A format stringben a következő karakterek lehetnek:
| formátum karakter | Leírás | Példák visszaadott értékekre |
|---|---|---|
| Nap | --- | --- |
| d | Hónap napja 2 számjeggyel (előtte 0, ha kell) | 01-től 31-ig |
| D | A hét napjának szöveges reprezentációja három betűvel | Mon .. Sun |
| j | A hónap napja, felesleges nullák nélkül | 1-től 31-ig |
| l (kis 'L') | A hét napjának hosszú szöveges reprezentációja | Sunday .. Saturday |
| S | A hónap napjához tartozó angol sorszám-utója, 2 karakter | st, nd, rd vagy th. Jól hasznáható a j-vel együtt. |
| w | A hét napjának számreprezentációja | 0-tól (Vasárnap) 6-ig (Szombat) |
| z | Az év napja (0-tól kezdve) | 0-tól 365-ig |
| Hét | --- | --- |
| W | Év hetének a száma ISO-8601 szerint. A hetek hétfőn kezdődnek. (PHP 4.1.0-tól) | Példa: 42 (a 42. hét az évben) |
| Hónap | --- | --- |
| F | A hónap szöveges reprezentációja | January .. December |
| m | A hónap számreprezentációja, 2 számjeggyel | 01-től 12-ig |
| M | A hónap szöveges reprezentációja három betűvel | Jan .. Dec |
| n | A hónap számreprezentációja, felesleges nullák nélkül | 1-től 12-ig |
| t | A napok száma az adott hónapban | 28-tól 31-ig |
| Év | --- | --- |
| L | Szőkőév van-e vagy sem | 1 szökőév esetén, 0 egyébként. |
| Y | Az év 4 számjegyű számreprezentációka | Példák: 1999, 2003 |
| y | Az év 2 számjegyű számreprezentációja | Példák: 99, 03 |
| Idő | --- | --- |
| a | "am" vagy "pm" (délelőtt vagy délután) | am vagy pm |
| A | "AM" vagy "PM" (ugyanez nagybetűvel) | AM vagy PM |
| B | Swatch Internet time | 000-tól 999-ig |
| g | Óra 12 órás formátumban, felesleges nullák nélkül | 1-től 12-ig |
| G | Óra 24 órás formátumban, felesleges nullák nélkül | 0-tól 23-ig |
| h | Óra 12 órás formátumban, 2 számjeggyel | 01-től 12-ig |
| H | Óra 24 órás formátumban, 2 számjeggyel | 00-tól 23-ig |
| i | Percek, 2 számjeggyel | 00-tól 59-ig |
| s | Másodpercek, 2 számjeggyel | 00-tól 59-ig |
| Időzóna | --- | --- |
| I (nagy i) | A nyári időszámítás van-e vagy sem | 1 nyári időszámítás alatt, 0 egyébként. |
| O | Különbség a Greenwich-i (GMT) és a helyi idő között órákban | Példa: +0200 |
| T | A gép időzóna beállítása | Példák: EST, MDT ... |
| Z | Időzóna eltolás másodpercekben. Az UTC-től nyugatra mindig negatív, keletre pedig pozitív. | -43200-tól 43200-ig |
| Teljes dátum, idő | --- | --- |
| c | ISO 8601 date (PHP 5-től) | 2004-02-12T15:19:21+00:00 |
| r | RFC 2822 formátumű dátum | Példa: Thu, 21 Dec 2000 16:01:07 +0200 |
| U | A Unix Epoch (January 1 1970 00:00:00 GMT) óta eltelt másodpercek száma | Lásd még a time() függvényt |
A formátumstringben levő, egyéb karakterek egy az egyben megjelennek. A Z betű mindig 0-val tér vissza, ha a gmdate()-et használjuk.
Példa 1. date() példák
|
A felismert karaktereket a formátumstringben backslash-sel tudod megvédeni. Ha a karakter backslash karakter után is speciális jelentéssel bír, akkor a backslash-t is meg kell védeni a kiértékeléstől.
A date()-et és a mktime()-ot ügyesen együtt használva információt szerezhetsz múltbeli és jövőbeli időpontokról.
Példa 3. date() és mktime() példa
|
Megjegyzés: Ez sokkal megbízhatóbb, mint az időbélyegekkel számolni (gondolj a téli-nyári időszámításkori átállásokra)
Néhány példa a date() függvény formázására. Figyeld meg, hogy az összes karaktert meg kell védened a kiértékeléstől, nem csupán azokat, amlyeknek már most speciális jelentésük van, ugyanis egy jövőbeli PHP változatban ezek is jelentést kaphatnak. Amikor egy karaktert megvédesz az értelmezéstől, használj aposztrófokat a karakterlánc megadására, hogy pl. a \n újsorokká történő átalakítását megakadályozd.
Példa 4. A date() függvyény formátumstringje
|
Ha a dátumokat más nyelven szeretnéd megkapni, használd a setlocale() és a strftime() függvényeket.
Lásd még a getlastmod(), gmdate(), mktime(), strftime() és a time() függvényeket.
A timestamp-ben megadott idõpontról (vagy a jelen pillanatról, ha a timestamp nincs megadva) ad információt asszociatív tömb formájában. A következõ elemeket tartalmazza:
Táblázat 1. A visszatérített asszociatív tömb elemei
| Kulcs | Leírás | Példák visszaadott értékekre |
|---|---|---|
| "seconds" | A másodpercek számreprezentációja | 0-tól 59-ig |
| "minutes" | Percek számreprezentációja | 0-tól 59-ig |
| "hours" | Órák számreprezentációja | 0-tól 23-ig |
| "mday" | A hónap napjának számreprezentációja | 1-tõl 31-ig |
| "wday" | A hét napának számreprezentációja | 0-tól (vasárnap) 6-ig (szombat) |
| "mon" | A hónap számreprezentációja | 1-tõl 12-ig |
| "year" | Az év 4 számjegyes számreprezentációja | Példák: 1999, 2003 |
| "yday" | Az év napjának számreprezentációja | 0-tól 365-ig |
| "weekday" | A hét napjának szöveges reprezentációja | Sunday-tõl Saturday-ig |
| "month" | A hónap szöveges reprezentációja | January-tól December-ig |
| 0 | A Unix Epoch óta eltelt másodpercek száma, hasonlóan a time() által visszaadott, valamint a date() által használt értékhez. | Rendszerfüggõ, tipikusan -2147483648-tól 2147483647-ig. |
Lásd még: date(), time(), setlocale().
Ez egy felület a gettimeofday(2)-höz. Egy asszociatív tömbbel tér vissza, tartalmazza a rendszerhívásból származó adatokat.
A PHP 5.1.0 óta létezik a return_float opcionális paraméter, amelynek TRUE-ra állítása azt eredményezi, hogy a gettimeofday() float értéket ad vissza.
A tömb kulcsai:
"sec" - másodperc
"usec" - mikroszekundum ["mikromásodperc"]
"minuteswest" - hány percet kell hozzáadni a helyi időhöz, hogy a Greenwichit kapjuk
"dsttime" - nyári időszámítási korrekció típusa [???]
Azonos a date() függvénnyel, kivéve, hogy az időpont Greenwichi idő szerint van(GMT). Például, ha Finnországban fut (GMT +0200), az első sor lent kiírja, hogy "Jan 01 1998 00:00:00", míg a második pedig azt, hogy "Dec 31 1997 22:00:00".
Megjegyzés: A Microsoft Windows operációs rendszerek esetén ezt a függvény implementáló rendszerkönyvtárak hibásak, ezért a gmdate() nem fogad el negatív számokat. Részletekért lásd a következő hibajelentéseket: #22620, #22457, #14391.
Ez a probléma nem jelentkezik a Unix/Linux operációs rendszereken, mivel a rendszerkönyvtárak helyesen működnek.
A PHP nem tudja helyrehozni a hibás rendszerkönyvtárakat. A probléma javításához fordulj az operációs rendszert készítő céghez.
Lásd még a date(), mktime(), gmmktime() és a strftime() függvényeket.
Azonos a mktime() függvénnyel, kivéve, hogy az átadott paraméterek GMT időpontként értelmezettek.
A paraméterek mindig GMT dátumot kell jelöljenek, ezért az is_dst paraméter nem befolyásolja az eredményt.
Megjegyzés: A gmmktime() az mktime() függvényt használja, ezért csak a származtatott helyi idő szerint érvényes időpontok használhatóak.
Hasonlóan a mktime() függvényhez, az argumentumok jobbról balra sorra elhagyhatóak, minden kihagyott argumentum az aktuális GMT értékre állítódik be.
(PHP 3 >= 3.0.12, PHP 4, PHP 5)
gmstrftime -- Az aktuális helyi időből számított GMT/UTC időpontot ad vissza.A strftime()-hoz hasonlóan viselkedik, kivéve, hogy a függvény által visszaadott időpont GMT formátumban van. Például, ha "Keleti Standard Idő"-ben(GMT -0500) vagyunk, a következő sor kiírja, hogy "Dec 31 1998 20:00:00", míg a második azt írja ki, hogy "Jan 01 1999 01:00:00".
Lásd még a strftime() függvényt.
Egy egész értékkel tér vissza, amely a formátumstring szerinti alakban tartalmazza a timestamp dátumot, ennek hiányában az aktuális helyi időt. Más szóval, a timestamp paraméter elhagyható és az alapértelmezett értéke a time() függvény értéke.
A date() függvénnyel ellentétben, az idate() csak egy karaktert vár a format paraméterben.
Táblázat 1. A format paraméterben az alábbi karakterek lehetnek:
| Formátum karakter | Leírás |
|---|---|
| B | Swatch Beat/Internet Time |
| d | Hónap napja |
| h | Óra 12 órás formátumban |
| H | Óra 24 órás formátumban |
| i | Perc |
| I | 1 nyári időszámítás alatt, 0 egyébként. |
| L | 1 szökőév esetén, 0 egyébként |
| m | Hónap |
| s | Másodperc |
| t | A hónapbeli napok száma |
| U | A Unix Epoch (January 1 1970 00:00:00 GMT) óta eltelt másodpercek száma. Ugyanaz mint a time() függvény |
| w | A hét napja (vasárnap: 0) |
| W | Év hetének a száma ISO-8601 szerint, a hetek hétfőn kezdődnek |
| y | Év 1 vagy 2 számjeggyel (lásd a lenti megjegyzést) |
| Y | Év 4 számjeggyel |
| z | Év napja |
| Z | Időzóna eltolás másodpercekben |
Megjegyzés: Mivel az idate() függvény mindig integer típusű értékkel tér vissza, amelyek nem kezdődhetnek "0"-val, az idate() a vártnál kevesebb számjeggyel térhet vissza. Lásd az alábbi példát:
A localtime() függvény egy tömböt ad vissza, ugyanolyan szerkezetben, mint azt a C nyelvbeli függvényhívás teszi. A localtime() függvény első argumentuma az időbélyeg; ha nincs megadva, az aktuális időt használja, ahogy azt a time() függvény produkálja. A második argumentum az is_associative, ha 0, vagy nincs megadva, hagyományos tömböt (numerikusan indexelve) kapunk vissza. Ha az argumentum 1, akkor a localtime() függvény asszociatív tömböt ad vissza, tartalmazva az összes elemet olyan struktúrában, amint azt a C függvénye is teszi a localtime függvényben. Az asszociatív tömb kulcsainak nevei a következők:
"tm_sec" - másodperc
"tm_min" - perc
"tm_hour" - óra
"tm_mday" - nap
"tm_mon" - hónap (!!! A Január 0 !!!)
"tm_year" - év, az 1900 óta eltelt évek száma
"tm_wday" - hét napja
"tm_yday" - év napja - 1
"tm_isdst" - nyári időszámítás aktív-e
Megjegyzés: A hónapok számozása 0-tól (január) 11-ig (december) történik, a hét napjainak számozása pedig 0-tól (vasárnap) 6-ig (szombat).
Példa 1. time() példa
A fenti példa valami ilyesmi kimenetet ad:
|
A microtime() az aktuális Unix időbélyeget adja vissza mikromásodpercekkel. Ez a függvény csak olyan operációs rendszereken elérhető, amely támogatja a gettimeofday() rendszerhívást.
Amikor az elhagyható argumentum nélkül hívod meg, a függvény a "msec sec" stringet adja vissza, ahol a sec a Unix Epoch (1970. január 1. 00:00:00 GMT) óta eltelt másodpercek száma, valamint a msec a mikromásodperc része. Mindkét részt másodpercben kapod meg.
Amikor a get_as_float meg van adva és értéke TRUE, akkor a microtime() függvény lebegőpontos értéket fog visszaadni.
Megjegyzés: A get_as_float paraméter a PHP 5.0.0 változatában lett bevezetve.
Példa 1. Szkript futásidejének mérése microtime() függvénnyel
|
Lásd még time() függvényt.
Figyelem! Vedd észre, hogy az argumentumok sorrendje nem éppen szokásos, mert különbözik a hagyományos Unix-os mktime()-étól, ezért nem igazán alkalmas arra, hogy lehagyd az utolsó néhány paramétert. Gyakori hiba scriptekben az argumentumok felcserélése.
Az argumentumok által megadott időpont UNIX időbélyegét adja. Ez tulajdonképpen egy nagy egész szám, a Unix Epoch (1970 Január 1. 00:00:00 GMT) és az adott idő közt eltelt másodpercek száma.
Jobbról elhagyhatsz argumentumokat; ezeket a php az aktuális helyi dátum és idő alapján pótolja.
Az is_dst paramétert állíthatod 1-re, jelezve, hogy a nyári időszámításban (DST) vagy, 0-ra, hogy nem, vagy -1-re (ez az alapértelmezett), ha nem tudod.
Egyes időpontok érvényelenek abban az esetben, ha a PHP-t futtató rendszeren a DST be van állítva vagy az is_dst értéke 1. Ha a DST 2:00-kor kerül beállításra, minden 2:00 és 3:00 közti idő érvénytelen, ezért az mktime() függvény határozatlan (általában negatív) értéket ad vissza. Egyes operációs rendszerek (például Solaris 8) a DST-t éjfélkor kapcsolják be, ezért a 0:30 időpont az előző napi 23:30-nak számít, ha a DST be van kapcsolva.
Megjegyzés: Az is_dst paraméter a 3.0.10.-es verzióban került a nyelvbe.
A mktime() függvény hasznos a dátumokkal való manipulálás, illetve dátumellenőrzés során, mivel automatikusan "korrekt" dátummá konvertálja a helytelenül megadott bemenetet.Példaul, az alábbi sorok mindegyike azt írja ki, hogy "Jan-01-1998".
Windows: Negtív időbélyegeket semmilyen ismert Windows rendszeren nem támogat. Emiatt az érvényes évek skálája 1970-től 2038-ig tart.
Adott hónap utolsó napját a következő hónap "0." napjával fejezhetjük ki (NEM a -1.-kel!!!). Az alábbi két példa mind azt írja ki, hogy "2000 februárjának utolsó napja: 29".
Az olyan dátum, amelyben az év, hónap, és a nap is nulla, nem legális (máskülönben 1999. 11. 30.-ának kellene tekinteni, ami furcsa viselkedés lenne)
Lásd még a gmmktime(), date() és a time() függvényeket.
A megadott formátumstringnek megfelelően formázott dátum-stringgel tér vissza, felhasználva a megadott timestamp paramétert, vagy ennek hiányában a helyi időt. Hónap, és napnevek, továbbá más nyelvfüggő stringek az setlocale() függvénnyel beállított értékeknek felelnek meg.
Az alábbi formátumstringeket ismeri fel a függvény:
%a - hét napja, rövidítve
%A - hét napja, teljes
%b - hónap neve, rövidítve
%B - hónap neve, teljes
%c - dátum és idő alapértelmezett formátumban
%C - évszám 2 utolsó jegy nélkül (trunc(év/100), értéke 00 és 99 között)
%d - nap, 2 számjegy ("01" .. "31")
%D - azonos %m/%d/%y-val
%e - nap, 2 karakter, extra szóközzel az egyjegyű számok előtt (" 1" .. "31")
%g - mint a %G, csak évszázad nélkül
%G - A 4-jegyű évszám, ami az ISO hétszámhoz tartozik (lásd a %V opciót). Ez azonos formátumú és értékű, mint a %Y, kivéve, hogy ha az ISO hétszám az előző, vagy a következő évhez tartozik, akkor azzal az évet adja.
%h - ugyanaz, mint a %b
%H - óra, 24-órás formátumban, 2 számjeggyel ("00" .. "23")
%I - óra, 12-órás formátumban, 2 számjeggyel ("01" .. "12")
%j - év napja, 3 számjegy ("001" .. "366" !!!)
%m - hónap, számmal ("01" .. "12") [van kitöltő szóköz]
%M - perc, [2 számjegy]
%n - újsor karakter
%p - `am' vagy `pm', annak megfelelően, hogy az adott időpont délelőtt, vagy délután van-e
%r - időpont 12 órás formátumban [pl.: 12:00:00 AM]
%R - időpont 24 órás formátumban [pl.: 00:00][Itt nincs másodperc!!!]
%S - másodperc [2 számjegy]
%t - tabulátor
%T - idő, azonos a %H:%M:%S-val
%u - hét napja, számmal [1,7], az 1 a hétfőt jelenti
| Figyelem |
Úgy tűnik, hogy Sun Solarison a vasárnap az 1-es, holott az ISO 9889:1999 (az aktuális C standard) világosan megmondja, hogy hétfőnek kell lennie. |
%U - az aktuális év hányadik hetében járunk, a hét vasárnappal kezdődik, vagyis az "01" hét január első vasárnapján kezdődik. [Az első hét előtti napokat "00" hétnek jelzi!!!]
%V - Az ISO 8601:1988 hétszám ("01" .. 53), ahol az az első hét, amelynek legalább 4 napja van az újévben. A hét első napja hétfő. Használd a %G-t vagy a %g-t, ha egy év kell, ami egy időbélyeg hétszámához tartozik. [???] [Helyesen kezeli az előző évből átnyúló heteket is]
%W - év hete, az év első hétfőjén kezdődik az "01" hét
%w - hét napja számmal, a vasárnap a 0
%x - alapértelmezett dátumformátum idő nélkül
%X - alapértelmezett időpontformátum dátum nélkül
%y - év 2 számjeggyel ("00" .. "99")
%Y - év, évszázaddal együtt
%Z vagy %z- időzóna neve [3 betű]
%% - a `%' karakter
Megjegyzés: Nem minden formátumstring van meg az összes C könyvtárban, ami azt jelenti, hogy a PHP strftime() függvényében sem lesznek elérhetők. Ráadásul nem minden platform támogatja a negatív időbélyegeket, ezért a előfordulhat, hogy nem használhatsz Unix Epoch előtti dátumot. Ez azt jelenti, hogy például a %e, %T, %R és a %D (esetleg egyebek is) nem fog működni 1970. január 1. előtti dátummal Windows-on, néhány Linux disztribűcióban, és még néhány egyéb operációs rendszeren. A Windows rendszerekre vonatkozóan a a támogatott konverzió leírókról található egy teljes áttekintés az MSDN weboldalon.
Megjegyzés: A %G és %V, amelyek az ISO 8601:1988 hétszámokra alapulnak, nem az elvárt (de a helyes) eredményt adják, ha nem értetted meg alaposan a számozási rendszert. Lásd a fenti %V-t valamint az alábbi példát week numbers can give unexpected (albeit correct) results if the numbering system is not thoroughly understood. See %V above and example below.
Példa 2. ISO 8601:1988 hétszámozási példa
|
Lásd még setlocale() és mktime(), strptime() és az Open Group specification of strftime()() függvényeket.
strptime() returns an array with the date parsed, or FALSE on error.
Month and weekday names and other language dependent strings respect the current locale set with setlocale() (LC_TIME).
Megjegyzés: Ez a függvény nem működik Windows operációs rendszereken!
The string to parse (e.g. returned from strftime())
The format used in date (e.g. the same as used in strftime()).
For more information about the format options, read the strftime() page.
Returns an array, or FALSE on failure.
Táblázat 1. The following parameters are returned in the array
| parameters | Description |
|---|---|
| tm_sec | Seconds after the minute (0-61) |
| tm_min | Minutes after the hour (0-59) |
| tm_hour | Hour since midnight (0-23) |
| tm_mday | Day of the month (1-31) |
| tm_mon | Months since January (0-11) |
| tm_year | Years since 1900 |
| tm_wday | Days since Sunday (0-6) |
| tm_yday | Days since January 1 (0-365) |
| unparsed | the date part which was not recognized using the specified format |
Példa 1. strptime() example
A fenti példa valami ilyesmi kimenetet ad:
|
(PHP 3 >= 3.0.12, PHP 4, PHP 5)
strtotime -- Mindenféle angol szöveges időpontot Unix időbélyeggé alakítA függvény egy stringet vár, amiben egy angolul írt dátum van, és megpróbálja Unix időbélyeggé (1970 január 1. 00:00:00 GMT óta eltelt másodpercek száma) konvertálni, a now paramétert, vagy ha az nincs megadva, az aktuális időpontot figyelembe véve. Ha a függvény nem tudja értelmezni a karakterláncot, -1-gyel tér vissza.
Mivel a strtotime() függvény a GNU dátum szintaxisnak megfelelően viselkedik, nézd meg a Date Input Formats című oldalakat a unix kézikönyvben (man). Ott le van írva a time paraméter pontos szintaxisa.
| Figyelem |
PHP 5 esetén az 5.0.2-es verzióig, a "now" és egyéb relatív időpontok az aznapi éjféltől számolódnak, helytelenül. Más verziókban ezt helyesen számolja: az aktuális időpontból. |
Példa 1. strtotime() példa
|
Megjegyzés: Az időpont érvényes időpontja tipikusan 1901 Dec. 13. 20:25:54 és 2038. Jan. 19. 03:14:07 közötti időpontot jelent (Greenwich-i időpont szerint) (Ezek a dátumok a legkisebb és a legnagyobb 32-bites egész szám által reprezentált dátumok) Nem minden platform támogatja a negatív időbélyegeket, ezért a előfordulhat, hogy nem használhatsz Unix Epoch előtti dátumot. Ez azt jelenti, hogy például a 1970. január 1. előtti dátum nem működik Windows-on, néhány Linux disztribűcióban, és még néhány egyéb operációs rendszeren.
A Unix Epoch (January 1 1970 00:00:00 GMT) óta eltelt másodpercek számát adja vissza.
Lásd még a date() és a microtime() függvényt!
| Figyelem |
Ez a kiterjesztés KÍSÉRLETI JELLEGGEL MŰKÖDIK. Ez azt jelenti, hogy minden itt dokumentált működés, beleértve a függvények nevét, működését vagy bármi más, amit a kiterjesztés kapcsán leírtunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a kiterjesztést csak a saját felelősségedre használd! |
db++, made by the German company Concept asa, is a relational database system with high performance and low memory and disk usage in mind. While providing SQL as an additional language interface, it is not really a SQL database in the first place but provides its own AQL query language which is much more influenced by the relational algebra than SQL is.
Concept asa always had an interest in supporting open source languages, db++ has had Perl and Tcl call interfaces for years now and uses Tcl as its internal stored procedure language.
This extension relies on external client libraries so you have to have a db++ client installed on the system you want to use this extension on.
Concept asa provides db++ Demo versions and documentation for Linux, some other Unix versions. There is also a Windows version of db++, but this extension doesn't support it (yet).
In order to build this extension yourself you need the db++ client libraries and header files to be installed on your system (these are included in the db++ installation archives by default). You have to run configure with option --with-dbplus to build this extension.
configure looks for the client libraries and header files under the default paths /usr/dbplus, /usr/local/dbplus and /opt/dblus. If you have installed db++ in a different place you have add the installation path to the configure option like this: --with-dbplus=/your/installation/path.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Most db++ functions operate on or return dbplus_relation resources. A dbplus_relation is a handle to a stored relation or a relation generated as the result of a query.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
Táblázat 1. DB++ Error Codes
| PHP Constant | db++ constant | meaning |
|---|---|---|
| DBPLUS_ERR_NOERR (integer) | ERR_NOERR | Null error condition |
| DBPLUS_ERR_DUPLICATE (integer) | ERR_DUPLICATE | Tried to insert a duplicate tuple |
| DBPLUS_ERR_EOSCAN (integer) | ERR_EOSCAN | End of scan from rget() |
| DBPLUS_ERR_EMPTY (integer) | ERR_EMPTY | Relation is empty (server) |
| DBPLUS_ERR_CLOSE (integer) | ERR_CLOSE | The server can't close |
| DBPLUS_ERR_WLOCKED (integer) | ERR_WLOCKED | The record is write locked |
| DBPLUS_ERR_LOCKED (integer) | ERR_LOCKED | Relation was already locked |
| DBPLUS_ERR_NOLOCK (integer) | ERR_NOLOCK | Relation cannot be locked |
| DBPLUS_ERR_READ (integer) | ERR_READ | Read error on relation |
| DBPLUS_ERR_WRITE (integer) | ERR_WRITE | Write error on relation |
| DBPLUS_ERR_CREATE (integer) | ERR_CREATE | Create() system call failed |
| DBPLUS_ERR_LSEEK (integer) | ERR_LSEEK | Lseek() system call failed |
| DBPLUS_ERR_LENGTH (integer) | ERR_LENGTH | Tuple exceeds maximum length |
| DBPLUS_ERR_OPEN (integer) | ERR_OPEN | Open() system call failed |
| DBPLUS_ERR_WOPEN (integer) | ERR_WOPEN | Relation already opened for writing |
| DBPLUS_ERR_MAGIC (integer) | ERR_MAGIC | File is not a relation |
| DBPLUS_ERR_VERSION (integer) | ERR_VERSION | File is a very old relation |
| DBPLUS_ERR_PGSIZE (integer) | ERR_PGSIZE | Relation uses a different page size |
| DBPLUS_ERR_CRC (integer) | ERR_CRC | Invalid crc in the superpage |
| DBPLUS_ERR_PIPE (integer) | ERR_PIPE | Piped relation requires lseek() |
| DBPLUS_ERR_NIDX (integer) | ERR_NIDX | Too many secondary indices |
| DBPLUS_ERR_MALLOC (integer) | ERR_MALLOC | Malloc() call failed |
| DBPLUS_ERR_NUSERS (integer) | ERR_NUSERS | Error use of max users |
| DBPLUS_ERR_PREEXIT (integer) | ERR_PREEXIT | Caused by invalid usage |
| DBPLUS_ERR_ONTRAP (integer) | ERR_ONTRAP | Caused by a signal |
| DBPLUS_ERR_PREPROC (integer) | ERR_PREPROC | Error in the preprocessor |
| DBPLUS_ERR_DBPARSE (integer) | ERR_DBPARSE | Error in the parser |
| DBPLUS_ERR_DBRUNERR (integer) | ERR_DBRUNERR | Run error in db |
| DBPLUS_ERR_DBPREEXIT (integer) | ERR_DBPREEXIT | Exit condition caused by prexit() * procedure |
| DBPLUS_ERR_WAIT (integer) | ERR_WAIT | Wait a little (Simple only) |
| DBPLUS_ERR_CORRUPT_TUPLE (integer) | ERR_CORRUPT_TUPLE | A client sent a corrupt tuple |
| DBPLUS_ERR_WARNING0 (integer) | ERR_WARNING0 | The Simple routines encountered a non fatal error which was corrected |
| DBPLUS_ERR_PANIC (integer) | ERR_PANIC | The server should not really die but after a disaster send ERR_PANIC to all its clients |
| DBPLUS_ERR_FIFO (integer) | ERR_FIFO | Can't create a fifo |
| DBPLUS_ERR_PERM (integer) | ERR_PERM | Permission denied |
| DBPLUS_ERR_TCL (integer) | ERR_TCL | TCL_error |
| DBPLUS_ERR_RESTRICTED (integer) | ERR_RESTRICTED | Only two users |
| DBPLUS_ERR_USER (integer) | ERR_USER | An error in the use of the library by an application programmer |
| DBPLUS_ERR_UNKNOWN (integer) | ERR_UNKNOWN |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
This function will add a tuple to a relation. The tuple data is an array of attribute/value pairs to be inserted into the given relation. After successful execution the tuple array will contain the complete data of the newly created tuple, including all implicitly set domain fields like sequences.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_aql() will execute an AQL query on the given server and dbpath.
On success it will return a relation handle. The result data may be fetched from this relation by calling dbplus_next() and dbplus_current(). Other relation access functions will not work on a result relation.
Further information on the AQL A... Query Language is provided in the original db++ manual.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_chdir() will change the virtual current directory where relation files will be looked for by dbplus_open(). dbplus_chdir() will return the absolute path of the current directory. Calling dbplus_chdir() without giving any newdir may be used to query the current working directory.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Calling dbplus_close() will close a relation previously opened by dbplus_open().
Returns TRUE on success or DBPLUS_ERR_UNKNOWN on failure.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_curr() will read the data for the current tuple for the given relation and will pass it back as an associative array in tuple.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
See also dbplus_first(), dbplus_prev(), dbplus_next(), and dbplus_last().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_errcode() returns a cleartext error string for the error code passed as errno of for the result code of the last db++ operation if no parameter is given.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_errno() will return the error code returned by the last db++ operation.
See also dbplus_errcode().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_find() will place a constraint on the given relation. Further calls to functions like dbplus_curr() or dbplus_next() will only return tuples matching the given constraints.
Constraints are triplets of strings containing of a domain name, a comparison operator and a comparison value. The constraints parameter array may consist of a collection of string arrays, each of which contains a domain, an operator and a value, or of a single string array containing a multiple of three elements.
The comparison operator may be one of the following strings: '==', '>', '>=', '<', '<=', '!=', '~' for a regular expression match and 'BAND' or 'BOR' for bitwise operations.
See also dbplus_unselect().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_curr() will read the data for the first tuple for the given relation, make it the current tuple and pass it back as an associative array in tuple.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
See also dbplus_curr(), dbplus_prev(), dbplus_next(), and dbplus_last().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_flush() will write all changes applied to relation since the last flush to disk.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_freealllocks() will free all tuple locks held by this client.
See also dbplus_getlock(), dbplus_freelock(), and dbplus_freerlocks().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_freelock() will release a write lock on the given tuple previously obtained by dbplus_getlock().
See also dbplus_getlock(), dbplus_freerlocks(), and dbplus_freealllocks().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_freerlocks() will free all tuple locks held on the given relation.
See also dbplus_getlock(), dbplus_freelock(), and dbplus_freealllocks().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_getlock() will request a write lock on the specified tuple. It will return zero on success or a non-zero error code, especially DBPLUS_ERR_WLOCKED, on failure.
See also dbplus_freelock(), dbplus_freerlocks(), and dbplus_freealllocks().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_getunique() will obtain a number guaranteed to be unique for the given relation and will pass it back in the variable given as uniqueid.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_curr() will read the data for the last tuple for the given relation, make it the current tuple and pass it back as an associative array in tuple.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
See also dbplus_first(), dbplus_curr(), dbplus_prev(), and dbplus_next().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_lockrel() will request a write lock on the given relation. Other clients may still query the relation, but can't alter it while it is locked.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_curr() will read the data for the next tuple for the given relation, will make it the current tuple and will pass it back as an associative array in tuple.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
See also dbplus_first(), dbplus_curr(), dbplus_prev(), and dbplus_last().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
The relation file name will be opened. name can be either a file name or a relative or absolute path name. This will be mapped in any case to an absolute relation file path on a specific host machine and server.
On success a relation file resource (cursor) is returned which must be used in any subsequent commands referencing the relation. Failure leads to a zero return value, the actual error code may be asked for by calling dbplus_errno().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_curr() will read the data for the previous tuple for the given relation, will make it the current tuple and will pass it back as an associative array in tuple.
The function will return zero (aka. DBPLUS_ERR_NOERR) on success or a db++ error code on failure. See dbplus_errcode() or the introduction to this chapter for more information on db++ error codes.
See also dbplus_first(), dbplus_curr(), dbplus_next(), and dbplus_last().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rchperm() will change access permissions as specified by mask, user and group. The values for these are operating system specific.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rcreate() will create a new relation named name. An existing relation by the same name will only be overwritten if the relation is currently not in use and overwrite is set to TRUE.
domlist should contain the domain specification for the new relation within an array of domain description strings. ( dbplus_rcreate() will also accept a string with space delimited domain description strings, but it is recommended to use an array). A domain description string consists of a domain name unique to this relation, a slash and a type specification character. See the db++ documentation, especially the dbcreate(1) manpage, for a description of available type specifiers and their meanings.
(4.1.0 - 4.2.3 only, PECL)
dbplus_rcrtexact -- Creates an exact but empty copy of a relation including indices| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rcrtexact() will create an exact but empty copy of the given relation under a new name. An existing relation by the same name will only be overwritten if overwrite is TRUE and no other process is currently using the relation.
Returns resource on success or DBPLUS_ERR_UNKNOWN on failure.
(4.1.0 - 4.2.3 only, PECL)
dbplus_rcrtlike -- Creates an empty copy of a relation with default indices| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rcrtexact() will create an empty copy of the given relation under a new name, but with default indices. An existing relation by the same name will only be overwritten if overwrite is TRUE and no other process is currently using the relation.
Returns resource on success or DBPLUS_ERR_UNKNOWN on failure.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_resolve() will try to resolve the given relation_name and find out internal server id, real hostname and the database path on this host. The function will return an array containing these values under the keys 'sid', 'host' and 'host_path' or FALSE on error.
See also dbplus_tcl().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rkeys() will replace the current primary key for relation with the combination of domains specified by domlist.
domlist may be passed as a single domain name string or as an array of domain names.
Returns resource on success or DBPLUS_ERR_UNKNOWN on failure.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_ropen() will open the relation file locally for quick access without any client/server overhead. Access is read only and only dbplus_current() and dbplus_next() may be applied to the returned relation.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rquery() performs a local (raw) AQL query using an AQL interpreter embedded into the db++ client library. dbplus_rquery() is faster than dbplus_aql() but will work on local data only.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rrename() will change the name of relation to name.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rsecindex() will create a new secondary index for relation with consists of the domains specified by domlist and is of type type
domlist may be passed as a single domain name string or as an array of domain names.
Returns resource on success or DBPLUS_ERR_UNKNOWN on failure.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_unlink() will close and remove the relation.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_rzap() will remove all tuples from relation.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
A db++ server will prepare a TCL interpreter for each client connection. This interpreter will enable the server to execute TCL code provided by the client as a sort of stored procedures to improve the performance of database operations by avoiding client/server data transfers and context switches.
dbplus_tcl() needs to pass the client connection id the TCL script code should be executed by. dbplus_resolve() will provide this connection id. The function will return whatever the TCL code returns or a TCL error message if the TCL code fails.
See also dbplus_resolve().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_tremove() removes tuple from relation if it perfectly matches a tuple within the relation. current, if given, will contain the data of the new current tuple after calling dbplus_tremove().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
| Figyelem |
Ez a függvény jelenleg nincs dokumentálva, csak a paraméterek listája található itt. |
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_unlockrel() will release a write lock previously obtained by dbplus_lockrel().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
Calling dbplus_unselect() will remove a constraint previously set by dbplus_find() on relation.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_update() replaces the tuple given by old with the data from new if and only if old completely matches a tuple within relation.
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_xlockrel() will request an exclusive lock on relation preventing even read access from other clients.
See also dbplus_xunlockrel().
| Figyelem |
Ez a függvény KÍSÉRLETI JELLEGGEL MŰKÖDIK. A függvény működése, neve, bármi amit a függévénnyel kapcsolatban dokumentáltunk megváltozhat egy későbbi PHP kiadásban minden figyelmeztetés nélkül. Ezt a függvényt csak a saját felelősségedre használd! |
dbplus_xunlockrel() will release an exclusive lock on relation previously obtained by dbplus_xlockrel().
These functions build the foundation for accessing Berkeley DB style databases.
This is a general abstraction layer for several file-based databases. As such, functionality is limited to a common subset of features supported by modern databases such as Sleepycat Software's DB2. (This is not to be confused with IBM's DB2 software, which is supported through the ODBC functions.)
The behaviour of various aspects depends on the implementation of the underlying database. Functions such as dba_optimize() and dba_sync() will do what they promise for one database and will do nothing for others. You have to download and install supported dba-Handlers.
Táblázat 1. List of DBA handlers
| Handler | Notes |
|---|---|
| dbm | Dbm is the oldest (original) type of Berkeley DB style databases. You should avoid it, if possible. We do not support the compatibility functions built into DB2 and gdbm, because they are only compatible on the source code level, but cannot handle the original dbm format. |
| ndbm | Ndbm is a newer type and more flexible than dbm. It still has most of the arbitrary limits of dbm (therefore it is deprecated). |
| gdbm | Gdbm is the GNU database manager. |
| db2 | DB2 is Sleepycat Software's DB2. It is described as "a programmatic toolkit that provides high-performance built-in database support for both standalone and client/server applications. |
| db3 | DB3 is Sleepycat Software's DB3. |
| db4 | DB4 is Sleepycat Software's DB4. This is available since PHP 4.3.2. |
| cdb | Cdb is "a fast, reliable, lightweight package for creating and reading constant databases." It is from the author of qmail and can be found at http://cr.yp.to/cdb.html. Since it is constant, we support only reading operations. And since PHP 4.3.0 we support writing (not updating) through the internal cdb library. |
| cdb_make | Since PHP 4.3.0 we support creation (not updating) of cdb files when the bundled cdb library is used. |
| flatfile | This is available since PHP 4.3.0 for compatibility with the deprecated dbm extension only and should be avoided. However you may use this where files were created in this format. That happens when configure could not find any external library. |
| inifile | This is available since PHP 4.3.3 to be able to modify php.ini files from within PHP scripts. When working with ini files you can pass arrays of the form array(0=>group,1=>value_name) or strings of the form "[group]value_name" where group is optional. As the functions dba_firstkey() and dba_nextkey() return string representations of the key there is a new function dba_key_split() available since PHP 5 which allows to convert the string keys into array keys without loosing FALSE. |
| qdbm | This is available since PHP 5.0.0. The qdbm library can be loaded from http://qdbm.sourceforge.net. |
When invoking the dba_open() or dba_popen() functions, one of the handler names must be supplied as an argument. The actually available list of handlers is displayed by invoking phpinfo() or dba_handlers().
By using the --enable-dba=shared configuration option you can build a dynamic loadable module to enable PHP for basic support of dbm-style databases. You also have to add support for at least one of the following handlers by specifying the --with-XXXX configure switch to your PHP configure line.
| Figyelem |
After configuring and compiling PHP you must execute the following test from commandline: php run-tests.php ext/dba. This shows whether your combination of handlers works. Most problematic are dbm and ndbm which conflict with many installations. The reason for this is that on several systems these libraries are part of more than one other library. The configuration test only prevents you from configuring malfaunctioning single handlers but not combinations. |
Táblázat 2. Supported DBA handlers
| Handler | Configure Switch |
|---|---|
| dbm |
To enable support for dbm add
--with-dbm[=DIR].
|
| ndbm |
To enable support for ndbm add
--with-ndbm[=DIR].
|
| gdbm | To enable support for gdbm add --with-gdbm[=DIR]. |
| db2 |
To enable support for db2 add
--with-db2[=DIR].
|
| db3 |
To enable support for db3 add
--with-db3[=DIR].
|
| db4 |
To enable support for db4 add
--with-db4[=DIR].
|
| cdb |
To enable support for cdb add
--with-cdb[=DIR].
|
| flatfile |
To enable support for flatfile add
--with-flatfile.
|
| inifile |
To enable support for inifile add
--with-inifile.
|
| qdbm |
To enable support for qdbm add
--with-qdbm[=DIR].
|
Megjegyzés: Up to PHP 4.3.0 you are able to add both db2 and db3 handler but only one of them can be used internally. That means that you cannot have both file formats. Starting with PHP 5.0.0 there is a configuration check avoid such misconfigurations.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
The functions dba_open() and dba_popen() return a handle to the specified database file to access which is used by all other dba-function calls.
DBA is binary safe and does not have any arbitrary limits. However, it inherits all limits set by the underlying database implementation.
All file-based databases must provide a way of setting the file mode of a new created database, if that is possible at all. The file mode is commonly passed as the fourth argument to dba_open() or dba_popen().
You can access all entries of a database in a linear way by using the dba_firstkey() and dba_nextkey() functions. You may not change the database while traversing it.
dba_close() closes the established database and frees all resources of the specified database handle.
dba_delete() deletes the specified entry from the database.
The key of the entry which is deleted.
The database handler, returned by dba_open() or dba_popen().
dba_exists() checks whether the specified key exists in the database.
The key the check is performed for.
The database handler, returned by dba_open() or dba_popen().
dba_fetch() fetches the data specified by key from the database specified with handle.
The key the data is specified by.
Megjegyzés: When working with inifiles this function accepts arrays as keys where index 0 is the group and index 1 is the value name. See: dba_key_split().
The number of key-value pairs to ignore when using cdb databases. This value is ignored for all other databases which do not support multiple keys with the same name.
The database handler, returned by dba_open() or dba_popen().
dba_firstkey() returns the first key of the database and resets the internal key pointer. This permits a linear search through the whole database.
dba_handlers() list all the handlers supported by this extension.
Returns an array of database handlers. If full_info is set to TRUE, the array will be associative with the handlers names as keys, and their version information as value. Otherwise, the result will be an indexed array of handlers names.
Megjegyzés: When the internal cdb library is used you will see cdb and cdb_make.
Példa 1. dba_handlers() Example
A fenti példa valami ilyesmi kimenetet ad:
|
dba_insert() inserts the entry described with key and value into the database.
The key of the entry to be inserted. If this key already exist in the database, this function will fail. Use dba_replace() if you need to replace an existent key.
The value to be inserted.
The database handler, returned by dba_open() or dba_popen().
dba_key_split() splits a key (string representation) into an array representation.
Returns an array of the form array(0 => group, 1 => value_name). This function will return FALSE if key is NULL or FALSE.
dba_nextkey() returns the next key of the database and advances the internal key pointer.
dba_open() establishes a database instance for path with mode using handler.
Commonly a regular path in your filesystem.
It is r for read access, w for read/write access to an already existing database, c for read/write access and database creation if it doesn't currently exist, and n for create, truncate and read/write access.
Additionally you can set the database lock method with the next char. Use l to lock the database with a .lck file or d to lock the databasefile itself. It is important that all of your applications do this consistently.
If you want to test the access and do not want to wait for the lock you can add t as third character. When you are absolutely sure that you do not require database locking you can do so by using - instead of l or d. When none of d, l or - is used, dba will lock on the database file as it would with d.
Megjegyzés: There can only be one writer for one database file. When you use dba on a webserver and more than one request requires write operations they can only be done one after another. Also read during write is not allowed. The dba extension uses locks to prevent this. See the following table:
Táblázat 1. DBA locking
already open mode = "rl" mode = "rlt" mode = "wl" mode = "wlt" mode = "rd" mode = "rdt" mode = "wd" mode = "wdt" not open ok ok ok ok ok ok ok ok mode = "rl" ok ok wait false illegal illegal illegal illegal mode = "wl" wait false wait false illegal illegal illegal illegal mode = "rd" illegal illegal illegal illegal ok ok wait false mode = "wd" illegal illegal illegal illegal wait false wait false
ok: the second call will be successfull. wait: the second call waits until dba_close() is called for the first. false: the second call returns false. illegal: you must not mix "l" and "d" modifiers for mode parameter.
The name of the handler which shall be used for accessing path. It is passed all optional parameters given to dba_open() and can act on behalf of them.
| Változat | Leírás |
|---|---|
| 4.3.0 | It's possible to open database files over network connection. However in cases a socket connection will be used (as with http or ftp) the connection will be locked instead of the resource itself. This is important to know since in such cases locking is simply ignored on the resource and other solutions have to be found. |
| 4.3.0 | Locking and the mode modifiers "l", "d", "-" and "t" were added. In previous PHP versions, you must use semaphores to guard against simultaneous database access for any database handler with the exception of GDBM. See System V semaphore support. |
| before 4.3.5 | open mode 'c' is broken for several internal handlers and truncates the database instead of appending data to an existent database. Also dbm and ndbm fail on mode 'c' in typical configurations (this cannot be fixed). |
dba_popen() establishes a persistent database instance for path with mode using handler.
Commonly a regular path in your filesystem.
It is r for read access, w for read/write access to an already existing database, c for read/write access and database creation if it doesn't currently exist, and n for create, truncate and read/write access.
The name of the handler which shall be used for accessing path. It is passed all optional parameters given to dba_popen() and can act on behalf of them.
dba_replace() replaces or inserts the entry described with key and value into the database specified by handle.
The key of the entry to be replaced.
The value to be replaced.
The database handler, returned by dba_open() or dba_popen().
These functions allow you to access records stored in dBase-format (dbf) databases.
dBase files are simple sequential files of fixed length records. Records are appended to the end of the file and delete records are kept until you call dbase_pack().
The types of dBase fields available are:
Táblázat 1. Available types of fields
| Field | dBase Type | Format | Additional information |
|---|---|---|---|
| M | Memo | n/a | This type is not supported by PHP, such field will be ignored |
| D | Date | YYYYMMDD | The field length is limited to 8 |
| N | Number | A number | You must declare a length and a precision (the number of digits after the decimal point) |
| C | String | A string | You must declare a length. When retrieving data, the string will be right-padded with spaces to fit the declared length. |
| L | Boolean | T or Y for TRUE, F or N for FALSE | Stored and returned as an integer (1 or 0) |
| F | Float | A float number | Support for this type of field was added in PHP 5.2.0 |
| Figyelem |
There is no support for indexes or memo fields. There is no support for locking, too. Two concurrent webserver processes modifying the same dBase file will very likely ruin your database. We recommend that you do not use dBase files as your production database. Choose any real SQL server instead; MySQL or Postgres are common choices with PHP. dBase support is here to allow you to import and export data to and from your web database, because the file format is commonly understood by Windows spreadsheets and organizers. |
In order to enable the bundled dbase library and to use these functions, you must compile PHP with the --enable-dbase option.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Many examples in this reference require a dBase database. We will use /tmp/test.dbf that will be created in the example of dbase_create().
Adds the given data to the database.
The database link identifier, returned by dbase_open() or dbase_create().
An indexed array of data. The number of items must be equal to the number of fields in the database, otherwise dbase_add_record() will fail.
Megjegyzés: If you're using dbase_get_record() return value for this parameter, remember to reset the key named deleted.
The database link identifier, returned by dbase_open() or dbase_create().
dbase_create() creates a dBase database with the given definition.
Megjegyzés: Ha a safe mode be van kapcsolva, a PHP ellenőrzi, hogy az állományok vagy könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program.
Megjegyzés: E függvény működése függ a open_basedir direktívától.
The name of the database. It can be a relative or absolute path to the file where dBase will store your data.
An array of arrays, each array describing the format of one field of the database. Each field consists of a name, a character indicating the field type, and optionally, a length, and a precision.
Megjegyzés: The fieldnames are limited in length and must not exceed 10 chars.
Returns a database link identifier if the database is successfully created, or FALSE if an error occurred.
Példa 1. Creating a dBase database file
|
Marks the given record to be deleted from the database.
Megjegyzés: To actually remove the record from the database, you must also call dbase_pack().
The database link identifier, returned by dbase_open() or dbase_create().
An integer which spans from 1 to the number of records in the database (as returned by dbase_numrecords()).
Returns information on the column structure of the given database link identifier.
The database link identifier, returned by dbase_open() or dbase_create().
An indexed array with an entry for each column in the database. The array index starts at 0.
Each array element contains an associative array of column information, as described here:
The name of the column
The human-readable name for the dbase type of the column (i.e. date, boolean, etc.)
The number of bytes this column can hold
The number of digits of decimal precision for the column
A suggested printf() format specifier for the column
The byte offset of the column from the start of the row
If the database header information cannot be read, FALSE is returned.
Példa 1. Showing header information for a dBase database file
|
(PHP 3 >= 3.0.4, PHP 4, PHP 5)
dbase_get_record_with_names -- Gets a record from a database as an associative arrayGets a record from a dBase database as an associative array.
The database link identifier, returned by dbase_open() or dbase_create().
The index of the record.
An associative array with the record. This will also include a key named deleted which is set to 1 if the record has been marked for deletion (see dbase_delete_record()).
Each field is converted to the appropriate PHP type, except:
Dates are left as strings.
Integers that would have caused an overflow (> 32 bits) are returned as strings.
On error, dbase_get_record_with_names() will return FALSE.
Példa 1. Listing all the registered members in the database
|
Gets a record from a database as an indexed array.
The database link identifier, returned by dbase_open() or dbase_create().
The index of the record.
An indexed array with the record. This array will also include an associative key named deleted which is set to 1 if the record has been marked for deletion (see dbase_delete_record()).
Each field is converted to the appropriate PHP type, except:
Dates are left as strings.
Integers that would have caused an overflow (> 32 bits) are returned as strings.
On error, dbase_get_record() will return FALSE.
Gets the number of fields (columns) in the specified database.
Megjegyzés: Field numbers are between 0 and dbase_numfields($db)-1, while record numbers are between 1 and dbase_numrecords($db).
The database link identifier, returned by dbase_open() or dbase_create().
Gets the number of records (rows) in the specified database.
Megjegyzés: Record numbers are between 1 and dbase_numrecords($db), while field numbers are between 0 and dbase_numfields($db)-1.
The database link identifier, returned by dbase_open() or dbase_create().
dbase_open() opens a dBase database with the given access mode.
Megjegyzés: Ha a safe mode be van kapcsolva, a PHP ellenőrzi, hogy az állományok vagy könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program.
Megjegyzés: E függvény működése függ a open_basedir direktívától.
The name of the database. It can be a relative or absolute path to the file where dBase will store your data.
An integer which correspond to those for the open() system call (Typically 0 means read-only, 1 means write-only, and 2 means read and write).
Megjegyzés: You can't open a dBase file in write-only mode as the function will fail to read the headers information and thus you can't use 1 as mode.
Returns a database link identifier if the database is successfully opened, or FALSE if an error occurred.
Packs the specified database by permanently deleting all records marked for deletion using dbase_delete_record().
The database link identifier, returned by dbase_open() or dbase_create().
Replaces the given record in the database with the given data.
The database link identifier, returned by dbase_open() or dbase_create().
An indexed array of data. The number of items must be equal to the number of fields in the database, otherwise dbase_add_record() will fail.
Megjegyzés: If you're using dbase_get_record() return value for this parameter, remember to reset the key named deleted.
An integer which spans from 1 to the number of records in the database (as returned by dbase_numrecords()).
Példa 1. Updating a record in the database
|
These functions allow you to store records stored in a dbm-style database. This type of database (supported by the Berkeley DB, GDBM, and some system libraries, as well as a built-in flatfile library) stores key/value pairs (as opposed to the full-blown records supported by relational databases).
Megjegyzés: However, dbm support is deprecated and you are encouraged to use the Database (dbm-style) abstraction layer functions instead.
Megjegyzés: This extension has been removed from PHP and is no longer available as of PHP 5.0.0.
To use this functions you have to compile PHP with support for an underlying database. See the list of supported Databases.
In order to use these functions, you must compile PHP with dbm support by using the --with-db option. In addition you must ensure support for an underlying database or you can use some system libraries.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
The function dbmopen() returns an database identifier which is used by the other dbm-functions.
Deletes the value for key in the database.
Returns FALSE if the key didn't exist in the database.
Returns TRUE if there is a value associated with the key.
Returns the value associated with key.
Returns the first key in the database. Note that no particular order is guaranteed since the database may be built using a hash-table, which doesn't guarantee any ordering.
Adds the value to the database with the specified key.
Returns -1 if the database was opened read-only, 0 if the insert was successful, and 1 if the specified key already exists. (To replace the value, use dbmreplace().)
Returns the next key after key. By calling dbmfirstkey() followed by successive calls to dbmnextkey() it is possible to visit every key/value pair in the dbm database. For example:
The first argument is the full-path filename of the DBM file to be opened and the second is the file open mode which is one of "r", "n", "c" or "w" for read-only, new (implies read-write, and most likely will truncate an already-existing database of the same name), create (implies read-write, and will not truncate an already-existing database of the same name) and read-write respectively.
Returns an identifier to be passed to the other DBM functions on success, or FALSE on failure.
If NDBM support is used, NDBM will actually create filename.dir and filename.pag files. GDBM only uses one file, as does the internal flat-file support, and Berkeley DB creates a filename.db file. Note that PHP does its own file locking in addition to any file locking that may be done by the DBM library itself. PHP does not delete the .lck files it creates. It uses these files simply as fixed inodes on which to do the file locking. For more information on DBM files, see your Unix man pages, or obtain GNU's GDBM.
Megjegyzés: Ha a safe mode be van kapcsolva, a PHP ellenőrzi, hogy az állományok vagy könyvtárak, amelyekkel dolgozni szeretnél, ugyanazzal a felhasználói azonosítóval (UID) rendelkeznek-e, mint az éppen futó program.
A dbx modul adatbázis-kezelő absztrakciós réteg, ahol az X jelenti a támogatott adatbáziskezelőket. A dbx függvényekkel azonos hívási konvenciót használva lehet elérni a támogatott adatbázisok mindegyikét. A dbx függvények önmagukban nem kommunikálnak az adatbázis-kiszolgálókkal, csak az őket támogató modulokkal/kiterjesztésekkel.
Annak érdekében, hogy ezeket a függvényeket használni lehessen,a be kell tölteni a dbx támogatást vagy hozzá kell linkelni a PHP-t. Jelenleg az alábbi adatbáziskezelőket támogatja a dbx:
Arról, hogyan kell új adatbázis támogatást implementálni a dbx modulba http://www.guidance.nl/php/dbx/doc/ címen találsz leírást.
Annak érdekében, hogy ezeket a függvényeket használni lehessen,a PHP-t dbx támogatással - az --enable-dbx kapcsoló - és minden használni kívánt adatbázisnak megfelelő kiterjesztéssel kell fordítani, azaz MySQL esetén --with-mysql kapcsolót is meg kell adni.
Ez a kiterjesztés semmilyen konfigurációs beállításokat nem definiál a php.ini állományban.
Két erőforrástípust használ a dbx kiterjesztés (egy - egy object típusút): az egyik az adatbázis-kapcsolat leíró, a másik az eredményhalmaz kezeléséhez szükséges .
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.
Siker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: Használd mindig az adatbázis specifikus dokumentációt is!
Lásd még: dbx_connect()!
0-val tér vissza, ha a row_a[$column_key] egyenlő a row_b[$column_key] kifejezéssel, és 1-gyel, ha az első nagyobb, illetve -1-gyel, ha ez kisebb. Ha flags értéke DBX_CMP_DESC, akkor pont fordított értékek adódnak eltérő bemenetek esetén. dbx_compare() kisegítő függvény a dbx_sort() használatához, hogy könnyebben lehessen írni és használni saját definiálású összehasonlító függvényeket.
A flags használható arra, hogy beállítsuk az a rendezés irányát:
DBX_CMP_ASC - növekvő sorrendet ír elő
DBX_CMP_DESC - csökkenő sorrendet ír elő
DBX_CMP_NATIVE - típuskonverzió nélkül hasonlítja össze az elemeket
DBX_CMP_NUMBER - számként hasonlítja össze az elemeket
DBX_CMP_TEXT - szövegként hasonlítja össze az elemeket
Példa 1. dbx_compare() példa
|
Lásd még dbx_sort()!
Sikeres csatlakozáskor egy object-et ad vissza, hiba esetén pedig FALSE-t. Ha sikerült a kapcsolatot létesíteni, de a megadott adatbázis nem elérhető, akkor a kapcsolatot lezárja és FALSE-t ad vissza. A persistent paraméternek DBX_PERSISTENT értéket adva perzisztens adatbázis kapcsolatot nyit.
A module paraméter lehet sztring is, de inkább a felsorolt állandók valamelyike használandó. A lehetséges értékek alább láthatók, de figyelembe veendő, hogy csak akkor működnek, ha az adott modul be van töltve.
DBX_MYSQL vagy "mysql"
DBX_ODBC vagy "odbc"
DBX_PGSQL vagy "pgsql"
DBX_MSSQL vagy "mssql"
DBX_FBSQL vagy "fbsql" (PHP 4.1.1-től kezdve)
DBX_SYBASECT vagy "sybase_ct" (PHP 4.2.0-tól kezdve)
A visszaadott objektum három tagváltozóval rendelkezik:
Az aktuálisan kiválasztott adatbázis nevét tartalmazza.
Ennek a kapcsolatazonosítónak a segítségével szükség esetén az adott modulra jellemző függvények valamelyike hívható meg.
Ezt a dbx kiterjesztés tartja fenn belső használatra, az éppen használt modul számát tárolja.
A host, database, username és a password paraméterek kötelezőek, de nem mindig kerülnek felhasználásra a modul ténylegesen kapcsolatot létesítő függvényétől függően.
Megjegyzés: Használd mindig az adatbázis specifikus dokumentációt is!
Lásd még: dbx_close()!
(PHP 4 >= 4.0.6, PHP 5 <= 5.0.4)
dbx_error -- visszaadja a modulban történt legutolsó hibát (nem feltétlenül a kapcsolathoz kötödő hibát)A hiba szövegét tartalmazó sztringgel tér vissza, amely a modulban legutolsó függvényhívás óta történt (pl. a mysql modulban). Ha az adott modulban több kapcsolat is nyitva van, akkor is csak a legutolsó hibaüzenet kerül visszadásra. Ha több modulhoz történt csatlakozás, akkor a link_identifier által meghatározott modul utolsó hibaüzenetét adja vissza.
Megjegyzés: Használd mindig az adatbázis specifikus dokumentációt is!
Microsoft SQL Server hibaüzenetei valójában a mssql_get_last_message() függvény visszatérési értékei.
(PHP 4 >= 4.3.0, PHP 5 <= 5.0.4)
dbx_escape_string -- Escape a string so it can safely be used in an sql-statementdbx_escape_string() returns the text, escaped where necessary (such as quotes, backslashes etc). It returns NULL on error.
Példa 1. dbx_escape_string() example
|
See also dbx_query().
(PHP 5 <= 5.0.4)
dbx_fetch_row -- Fetches rows from a query-result that had the DBX_RESULT_UNBUFFERED flag setdbx_fetch_row() returns a row on success, and 0 on failure (e.g. when no more rows are available). When the DBX_RESULT_UNBUFFERED is not set in the query, dbx_fetch_row() will fail as all rows have already been fetched into the results data property.
As a side effect, the rows property of the query-result object is incremented for each successful call to dbx_fetch_row().
Példa 1. How to handle the returned value
|
The result_identifier parameter is the result object returned by a call to dbx_query().
The returned object contains the same information as any row would have in the dbx_query result data property, including columns accessible by index or fieldname when the flags for dbx_guery were set that way.
See also dbx_query().
(PHP 4 >= 4.0.6, PHP 5 <= 5.0.4)
dbx_query -- végrehajt egy lekérdezést és visszaadja a teljes végeredményt (ha van)Az sql_statement sikeres végrehajtásakor 1-gyel vagy egy objektummal tér vissza, ez utóbbival csak olyan esetben, ha SQL utasításnak van végeredménye. Hiba esetén 0-t ad vissza.
Példa 1. A visszatérési érték lekezelésére
|
A flags paraméteren keresztül szabályozható a visszaadandó információ mennyisége. Ez a következő állandók logikai vagy kapcsolata lehet:
Ez mindig felhasználásra kerül , és hatására a visszatérési érték része lesz egy két dimenziós tömb, amelynek az első indexe a sorindex, a második az oszlopindex, azaz például a data[2][3]-ban a 2 jelöli a sort, a 3 az oszlopot. Az indexelés 0-tól kezdődik.
Ha a DBX_RESULT_ASSOC is meg van adva, akkor a minden esetben a DBX_RESULT_INFO-nak megfelelő értékeket is szolgáltatja a függvény.
Az oszlopokról ad információt: a mezők számáról, neveikről és típusaikról.
Ennek hatására az oszlopértékeket az oszlopnevekkel is lehet indexelni, azaz a visszaadott eredményhalmaz asszociatív tömbként is használható.
Ezek az asszociatív indexek valójában referenciák a numerikus indexelésű értékekre, így a data[0][0]-t módosítva a data[0]['az_első_oszlop_mező_neve'] is megváltozik.
DBX_RESULT_INDEX
DBX_RESULT_INDEX | DBX_RESULT_INFO
DBX_RESULT_INDEX | DBX_RESULT_INFO | DBX_RESULT_ASSOC - alapértelmezés, ha nincs megadva a flags.
A visszaadott objektumnak négy vagy öt tagváltozója van a flags-től függően:
Érvényes kapcsolatazonosító az adatbázishoz, és így szükség esetén az adott modulra jellemző függvények hívásához használható:
A cols és rows tagváltozók tárolják az eredményhalmaz méreteit: az oszlopok/mezők és a sorok/rekordok számát.
Az info tagváltozó csak akkor érhető el, ha a DBX_RESULT_INFO és/vagy DBX_RESULT_ASSOC szerepel a flags paraméterben. Ez olyan kétdimenzós tömb, amelynek két nevesített sora van (name és type) a mezőinformációk eléréséhez.
A data tagváltozó tartalmazza a tényleges végeredményt, az eredményhalmazt, ha van ilyen. Ha a DBX_RESULT_ASSOC is része a flags-nek, akkor az adatok $result->data[2]["mező_neve"] alakban is elérhetők lesznek, asszociatív tömbként kezelve a data-t.
Megjegyzés: Használd mindig az adatbázis specifikus dokumentációt is!
Lásd még: dbx_connect()!
(PHP 4 >= 4.0.6, PHP 5 <= 5.0.4)
dbx_sort -- dbx_query által visszaadott eredményhalmazt rendezi tetszőleges függvény segítségévelSiker esetén TRUE értékkel tér vissza, ellenkező esetben FALSE értéket ad.
Megjegyzés: Az SQL lekérdezésen belül használt rendezés (ORDER BY) mindig jobb hatásfokú, mint a dbx_sort() Ha lehet, mindig az előbbit használd!
Példa 1. dbx_sort() példa
|
Lásd még dbx_compare()!
PHP supports the direct io functions as described in the Posix Standard (Section 6) for performing I/O functions at a lower level than the C-Language stream I/O functions (fopen(), fread(),..). The use of the DIO functions should be considered only when direct control of a device is needed. In all other cases, the standard filesystem functions are more than adequate.
Megjegyzés: Ez a kiterjesztés átkerült a PECL tárba és már nem terjesztik a PHP-vel együtt ettől a verziótól kezdve: PHP 5.1.0.
This extension is only available on Windows Platforms as of PHP 5.0.0
Az itt leírt függvények használatához semmilyen külső függvénykönyvtár megléte nem szükségeltetik.
Az itt listázott állandókat ez a kiterjesztés definiálja, és csak akkor elérhetőek, ha az adott kiterjesztés be van fordítva a PHP-be, vagy dinamikusan betöltött.