+ Konu Cevaplama Paneli
Gösterilen sonuçlar: 1 ile 8 ve 8
Like Tree8Beğeni
  • 1 tarafından zeet06
  • 1 tarafından zeet06
  • 1 tarafından zeet06
  • 1 tarafından zeet06
  • 1 tarafından zeet06
  • 1 tarafından zeet06
  • 2 tarafından zeet06

Konu: Perl Programlama Nedir?

  1. #1
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb Perl Programlama Nedir?


    Perl nedir ?

    CGI/Perl ile sunucu taraflı programlama:CGI Nedir?

    CGI kelimesi, Common Gatevay Interface kelimelerinin başharflerinden oluşan bir kısaltmadır. Türkcesi de "ortak geçit arayüzü" anlamına gelir. CGI ile ziyaretci tarafından server'a bir iş yaptırılır. Bu iş ziyaretcinin veritabanı olarak kullanılan dosyalara belli konularda kayıt yapabilmesi şeklinde olabileceği gibi ziyaretci sayısının sayılması, cookie ile yapılan işlemler, web üzerinden mail gönderilmesi şeklinde geniş bir yelpazede devam eder. CGI programlarında c++, visual basic scripting gibi diller kullanılabilse de genel olarak CGI programlarında perl dili kullanılır.


    Bunun sebebi geniş hosting desteği ve perl dilinin köklü ve geniş bir dil oluşudur. Biz buradaki örneklerimizde ve anlatımlarımızda perl programlama dilini temel alacağız. CGI programlarının işleyişi hakkında örnek verecek olursak web sitemizi ziyaret eden kişilerin görüşlerini bildirebileceği bir ziyaretci defteri yaptığımızı düşünelim. Web sitemize gelen ziyaretci ziyaretci defterine girer, görüşlerini bir form vasıtasıyla doldurur ve Submit (Gönder) basarak formun "action" kodlarıyla belirlenen ve form vasıtasıyla bilgilerin gönderileceği adres olan CGI ya da PL dosyasına bilgiler "bilgi yumağı" halinde gönderilir. bilgileri alan CGI dosyası bu bilgileri kendisine verilen komutlar doğrultusunda açar, değişkenlere atar, dosyaya kaydeder ve isteğe bağlı olarak mail vasıtasıyla defter sahibinin mail adresine gönderir.


    Sonuç olarak da ziyaretciye bir teşekkür içeren html dosyası gösterir. Örneğimizde ziyaretci CGI dosyasına bilgileri gönderdi ve CGI dosyası da server'a bir "iş" yaptırdı (dosya açtırdı, dosyaya kaydetti, dosyayı kapattı, mail gönderdi ve teşekkür mesajı içeren html dosyası yazdırdı)

    CGI ile neler yapabiliriz?
    CGI dosyaları az önce de belirttiğim gibi server'a bir takım komutlar verip "iş" yaptıran programcıklardır. CGI dosyalarıyla web sitenizin ziyaretcilerle etkileşimini sağlayabilirsiniz. Onların görüşlerini ve önerilerini öğrenebilirsiniz. Bir takım bilgiler alıp dosyalara kaydettirebilir, daha sonra bu dosyaları inceleyip ziyaretcilerinizin görüşlerini öğrenebilirsiniz. Anket programlarıyla insanların istediğiniz konu hakkında düşüncelerini ve oranları öğrenebilirsiniz. Ziyaretci defteri hazırlayıp ziyaretcilerinizin görüşlerini alabilirsiniz.


    Forum programlarıyla insanların bilgilerini paylaşabilecekleri ortamlar hazırlayabilirsiniz. Mail formlarla ziyaretcileriniz web üzerinden size e-mail gönderebilmelerini sağlayabilirsiniz. Bunun dışında Toplist, mesaj tahtası vs. gibi programlarla hem web sitenize içerik katarsınız, hem de ziyaretci sayınızı arttırabilirsiniz.

    Perl ile sadece internette değil kendi bilgisayarınızda çalışan, bi takım işlerinizde pratiklik kazandıracak programlar da yapabilirsiniz.

    Perl öğrenmek zor ve zahmetlidir ama sonucunda bir "programlama dili" öğrenmiş olursunuz ve ilerde başka bir programlama diline geçtiğinizde özellikle döngüler ve değişkenler konusunda çok rahat edersiniz.

    Perl öğrenmek için ortalama html bilgisine (genel kodlar, özellikle form ve input etiketleri) sahip olmanız gerekiyor. Eğer yeterli derecede html bilgisine sahip değilseniz acemiler.net de ilgili bölümlerini ziyaret edebilirsiniz. Ayrıca bu konuda internette bir çok kaynak var. Bundan sonraki derslerde ortalama html bilgisine sahip olduğunuz varsayılacaktır.

    Buradaki örnek kodları mecbur kalmadıkca ya da kendi yazdığınız kodlarla karşılaştırmak gerekmedikce kullanmamanızı tavsiye ederim, kodları kendiniz yazarsanız hem eliniz alışır hem de hata yapa yapa hata yapmamayı, hatasız kod yazmayı öğrenirsiniz. Örnek kodları zip'li halde buradan indirebilirsiniz.
    Server kurlumu Perl ve Kişisel Web Server


    Giriş yazısında da belirittiğim gibi Perl programları sunucu (host) tarafında çalışan (server side) programlardır. Bu programların çalışabilmesi için bilgisayarda bir takım programların (server, perl) kurulu olması gerekir. Aksi taktirde sadece kaynak kodlarını görebilirsiniz programların işlem sonucu ekrana nasıl bir sayfa verdiğini (output) göremezsiniz. Bu derste bilgisayarımızda *.cgi ve *.pl dosyalarını çalıştırabilmek için Kişisel Web Server ve Active Perl kurulumunu anlatmaya çalışacağım.

    Windows için Active Perl

    Windows işletim sistemi altında Perl programlarını (*.cgi ve *.pl dosyalarını) çalıştırabilmek için öncelikle Windows için Active Perl'ün son versiyonunu çekip bilgisayarınıza kurmanız gerekiyor. Bu programı ActiveState.com adresinden edinebilirsiniz. Olası kurulum problemine karşı -bulabilirseniz- instmsi.exe dosyasına ihtiyacınız olabilir onu da indirin. Eğer oradan bulamazsanız Microsoft'un web sitesinde "instmsi" şeklinde arama yaparak edinebilirsiniz.

    Windows 98 için Xitami server kurulumu :

    Xitami pratik, kişisel kullanım için ideal, fazla ayar gerektirmeyen ve Windows altında *.cgi ve *.pl dosyalarını kolaylıkla ve hızlı bir şekilde çalıştırabilen bir server programıdır. Kurması, kaldırması ve kullanması çok kolaydır. Öncelikle Xitami'nin web sitesinden Xitami server programının son versiyonunu indirmelisiniz.

    Xitami server programı kurulduktan sonra server'ınızın ana dizini (başka bir dizine kurmadıysanız) C:\Xitami\webpages olacaktır. Url adresi olarak http://127.0.0.1 , http://localhost , http://makinanızın_ismi adreslerinden birini kullanabilirsiniz. Bilgisayarınızın adını Başlat/Denetim Masası/Ağ/Tanımlama yoluyla öğrenebilirsiniz. Dosyada gerekli ayarlamaları yaptıktan sonra cgi programlarını çalıştıracağınız dizin adresi http://localhost/altisim/cgi-bin olacaktır.

    Windows 98 için Personal Web Server Kurulumu :



    PWS programını Windows 98 CE kurulum cd'sinde add-ons klasörü içerisinde pws klasöründe bulabilirsiniz. PWS'yi kurduktan sonra sistem kayıtlarında (registry) bi takım ayarlar yapmanız gerekiyor. Yapmanız gereken ayarlar şunlar;
    • Başlat/Çalıştır yoluyla çıkan prompt'a "regedit" yazarak sistem kayıt düzenleyicisini açın,
    • Her ihtimale karşı sistem kayıtlarının yedeğini alın (Kayıt/Kayıt dosyası ver),
    • HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/W3SVC/Parameter/ScriptMap anahtarına yandaki artıları tıklaya tıklaya geçin,
    • Düzen menüsünü tıklayın, açılacak listede Yeni, açılacak alt-listede Dize Değeri maddesini seçin. Sağda, "Varsayılan..." satırının altında "Yeni Değer #1" adlı bir satır oluşacak ve bu kelimeler seçilecektir. Klavyede ".pl" yazın (Nokta işareti, p ve l harfleri). Sonra kKlavyede iki kere Enter�a basın; açılacak Dize Düzenle kutusunda "Değer verisi" hanesine kendi sisteminize uygun olan Perl�ün sabit diskteki yol bilgisini (Path) ile birlikte "%s %s" yazın. Örneğin:

      c:\Perl\bin\perl.exe %s %s
    • Ayarların geçerli olabilmesi için bilgisayarınızı yeniden başlatın.
    PWS problemsiz kurulduğunda bilgisayarınızın ana dizini C:\inetpub\wwwroot olacaktır. Url olarak http://127.0.0.1 , http://localhost , http://makina_adı adreslerinden birini kullanabilirsiniz.

    Bilgisayarınızın *.cgi ve *.pl dosyalarını çalıştırıp çalıştırmadığını denemek için aşağıdaki kodları cgi destekleyen dizininize merhaba.cgi ve merhaba.pl olarak kaydedip browser'ınızın adres satırına dosyanın bulunduğu dizinin url sini yazarak deneyin. Eğer ekrana "merhaba dünya" yazısı geliyorsa bilgisayarınız artık *.cgi ve *.pl dosyalarını tanıyor demektir.


    #!/usr/bin/perl

    # merhaba.cgi - merhaba.pl

    print "Content-type:text/html\n\n";

    print "Merhaba Dünya!";



    Dosyaları cgi ya da pl uzantılı kaydedebilmek için Bilgisayarım simgesine çift tıklayın, üstten Görünüm'ü tıklayın, Klasör seçenekleri'ni tıklayın ve sekmelerden Görünüm'ü seçin. Burada "Bilinen dosya türleri için dosya uzantılarını gizle" seçeneğinin yanındaki işareti kaldırın ve tamam'ı seçin. Daha sonra kaydettiğiniz dosyayı seçip sağ tıklayın, yeniden adlandır'ı tıklayın ve dosya adına "merhaba.cgi" yazın.


    NOT : Bu dosya, Xitami'de birçok alt site(Webpages içerisinde ayrı klasörler şeklinde) kullanılacağı ve bunların da kendi cgi-bin klasörlerine sahibolacağı düşünülerek hazırlanmıştır.
    Olmazsa olmaz gerekli kodlar

    Programları yazarken mutlaka kullanmamız gereken kodlar:
    Normal olarak Perl'ü anlatmaya değişkenlerden başlamam gerekiyor ama yaptığımız örneklerin çalışması ve daha anlaşılır olması için öncelikle bazı kodları ve bu kodların ne işe yaradığını öğrenmemiz gerektiğini düşündüğümden bu konuya öncelik verdim.

    Shebang nedir ve nasıl kullanılır?

    Perl unix tabanlı bir dildir ve genelde unix server'larda çalışır. İnternet'de CGI/Perl desteği veren hosting'lerin %99'u Linux ve diğer Unix türevleridir. Bir *.cgi ya da *.pl dosyasının unix server'da yorumlanıp çalışabilmesi için de en başına yorumlayıcısının (Perl programının) tam adresi verilmelidir. Windows altında PWS'de shebang vermenize gerek yoktur ama Xitami altında çalışırken shebang yazmazsanız ya da yanlış yazarsanız internal server error (hata 500) hatası alırsınız. Bunun için yazdığımız her dosyanın başına hangi platformda çalışırsanız çalışın mutlaka shebang yazmanız gereklidir. Shebang ya da diğer adıyla perl yolu server'a göre değişebilir ama genel olarak şu şekildedir;

    #!/usr/bin/perl

    Eğer herhangi bir programınızda Internal server error (hata 500) hatası alırsanız ilk kontrol etmeniz gereken yer dosyanın en başı yani perl yoludur.

    Belirttiğim gibi Windows altında çalışırken perl yolunun pek bir önemi yoktur ama dosyaları internet'e gönderdiğinizde çalışabilmesi için perl yolunun doğru olması şarttır. İnternetteki alanınızın perl yolunu öğrenmek için hosting'in web sitesinde Sıkca sorulan sorular (FAQ), yardım (Help/Support) bölümlerini araştırabilirsiniz ya da server sahibi firma adminlerine bir e-mail göndererek sorabilirsiniz.

    Dosyaya yazı ya da HTML kodu yazdıracaksanız mutlaka şu kodu kullanmanız gerekir :

    Eğer yazdığınız dosyanın içinde bir şekilde ekrana yazı ya da html kodu yazdıracaksanız programın çalışabilmesi için şu kodu yazdıracağınız yerden önce (tercihen shebang'dan sonra) mutlaka dosyaya eklemeniz gereklidir. Aksi halde kendi bilgisayarınızda çalışsa bile internette "premature end of script" ya da "bad header" hatalarından birini almanız olasıdır. Kullanmanız gereken kod:

    print "Content-type:text/html\n\n";

    Böylece bir önceki sayfada verdiğim kodun ilk 2 satırını ve ne işe yaradığını öğrenmiş oldunuz. Aynı örneği tekrar veriyorum:


    #!/usr/bin/perl
    # merhaba.cgi - merhaba.pl

    print "Content-type:text/html\n\n";

    print "Merhaba Dünya!";




    Son verdiğim, sayfaya yazı ya da html formatında yazı yazılacağını belirten (print "Content-type:text/html\n\n" kod cookie yazdırılmasından önce kullanılırsa cookie yazılamaz. cookie konusuna ileride değinilecek ve bu konu ayrıntılı olarak ele alınacak ama şimdiden aklınızda bulunsun.

    Hata ekran çıktısı :

    Normalde dosya yazılırken eğer synax ya da yazım hatası yapıldıysa boş bir ekran gelir ve hatayı bulup düzeltene kadar tüm dosyayı baştan sona gözden geçirmek gerekir ama eğer şu kodu dosyanın en başına shebang'dan sonra eklerseniz dosya içinde yapılan hata hangi satırda yapıldığı ile beraber ekrana yansır, böylece zaman kazanırsınız;

    use CGI::Carp "fatalsToBrowser";

    Bu kodun kullanılması zorunlu değildir ama programcıya büyük kolaylık sağlar.
    Output perl ile yazdırma

    Perl ile düzyazı ya da html formatında yazı yazdırma :
    Perl dili ile düzyazı ya da html formatında yazı yazdırıp ekrana çıktı verebilmek için print ""; komutu kullanılır fakat perl ile yazdırırken dikkat etmeniz gereken bazı noktalar vardır. Bazı karakterler perl için özel anlam taşır bu karakterleri düzyazı halinde kullanırken perl'ün bu karakterleri dikkate almamasını sağlamak amacıyla bu karakterlerin önlerine ters slash (\) koymanız gerekir. Bu özel karakterler şunlardır:

    Noktalı virgül ( : Perl yorumlayıcısı döküman içinde noktalı virgül görünce o satırın ve komutun bittiğini zanneder ve yeni bir komut bekler. Bu yüzden düzyazı ya da html yazdırırken noktalı virgül kullanmadan önce ters slash (\) kullanmanız gerekir aksi taktirde dosya çalışmaz ve hatanın nerden kaynaklandığını bulmak baya bir zamanınızı alabilir.

    Dollar ($) ve And (&) simgeleri : Bu iki simge Perl için özel anlam ifade eder. Bu anlamların ne olduğundan ve fonksiyonlarından bahsedeceğim şimdilik bilmemiz gereken bu iki simgenin düzyazı ya da html formatında yazdırılabilmesi için (tabii fonksiyonuna uygun kullanılmıyorsa) önüne ters slash (\) koymanız gerektiğidir.

    Çift tırnak (") : Çift tırnak Perl için özel anlam ifade eder. Perl çift tırnak görünce bir komutun başladığını ya da bittiğini anlar. Eğer düzyazı ya da html içerisinde çift tırnak kullanacaksanız önüne ters slash (\) koyarak perl'ün çift tırnağı görmezden gelmesini sağlayabilirsiniz.

    At (@) : @ işareti de perl için bir anlam ifade eder. Perl bu işareti görünce ilişkili dizi (hash) değişkenleri arar ve bulamadığı taktirde hata verir. Eğer düzyazı içinde bu işareti kullanacaksanız ters slash (\) işaretinden sonra kullanmalısınız.

    Yüzde (%) : Yüzde (%) işareti perl için hash dizi değişkeni başlangıcı anlamına gelir yani özel bir anlam ifade eder. Eğer düzyazı olarak ekrana yazdırmak istiyorsanız önüne ters slash (\) koymanız gerekir.

    Eğer düzyazı içerisinde ters slash (\) işareti kullanmanız gerekiyorsa 3 tane yanyana ters slash kullanmanız gerekir.

    Perl için özel anlam ifade eden simgelerin önüne sadece düzyazı olarak yazdıracaksanız ters slash (\) koymalısınız.

    Örnek : #!/usr/bin/perl

    # duzyazi.cgi

    print "Content-type:text/html\n\n";

    print "<html>";
    print "<head>";
    print "<title>Düzyazı Dosyası</title>";
    print "<META content=\"text/html\; charset=ISO-8859-9\" http-equiv=content-type\">";
    print "</head>";
    print "<body bgcolor=\"#000000\">";
    print "<br><br>";
    print "<font face=\"verdana\" size=\"2\" color=\"#FFFFFF\">";
    print "CGI/Perl programları yazarken özel karakterlerin (\$,\&, \@, \;,\") önüne ters slash (\\\) koymayı unutmayın!";
    print "</font>";
    print "</body>";
    print "</html>";




    Yukarıdaki örnekten herhangi bir ters slash (\) işaretini kaldırıp sonucunu ve perl'e neden "öğrenmesi zor bir dil" dediklerini görebilirsiniz . Tavsiyem burda biraz durun ve bol bol ekrana düzyazı yazdıran kodlar yazın ve elinizi alıştırın.

    Perl ile html yazdırmanın aslında daha kolay fakat kullanışsız bir yöntemi daha vardır. Kolaylığı Perl'ün bu kullanım şeklinde tüm yazıları html olarak algılaması ve ters slash kullanımına gerek kalmamasıdır, kullanışsızlığı ise satırlar arasında herhangi bir döngü ya da alt program çalıştırılamaması, perl'ün fonksiyonel olarak kullanılamamasıdır. Yukarıdaki aynı kodları şu şekilde de yazdırabilirdik:

    #!/usr/bin/perl

    # duzyazi2.cgi

    print "Content-type:text/html\n\n";

    print <<HtmlBitis
    <html>
    <head>
    lttitle>Düzyazı Dosyası</title>
    <META content=\"text/html\; charset=ISO-8859-9\" http-equiv=content-type\">
    </head>
    <body bgcolor=\"#000000\">
    <br><br>
    <font face=\"verdana\" size=\"2\" color=\"#FFFFFF\">
    CGI/Perl programları yazarken özel karakterlerin (\$,\&, \@, \;,\") önüne ters slash (\\\) koymayı unutmayın!
    </font>
    </body>
    </html>
    HtmlBitis
    ;


    Bu kodu yazması daha kolaydır fakat kullanışsızdır. Bundan sonraki örneklerimde ilk verdiğim şekilde kullanacağım, sizin de öyle yapmanızı öneririm.
    Perl ile değişkenler

    Perl'de değişkenler :
    Herhangi bir programlama dili öğrenmeye çalıştığınızda ilk öğrenmeniz gereken kavram "değişken" kavramıdır. Değişkenlerin Perl dilinde de önemi büyüktür. En basitinden ziyaretci form vasıtasıyla veritabanına yazı yazdırırken bu veriler önce ayrı ayrı değişkenlere atanır daha sonra veritabanına girdisi sağlanır. Perl dilinde 3 tür değişken vardır. Değişkenlerin başlangıcında perl'ün değişkeni algılayacağı işaret vardır. Eğer değişken tekil değişken ise dollar ($), dizi değişken ise at (@), ilişkili dizi değişken ise yüzde (%) işareti değişken atanırken değişken isminden önce yazılır. Değişken isimleri rakam ya da harf olabilir ama işaretlerden sadece alt çizgi (_) kullanılabilir.

    Tekil (Scalar) değişkenler :

    Tekil değişkenler içeriğinde belli bir yazı, rakam ya da işaret ($#"%&...) tutarlar. Perl bir kodun tekil değişken olduğunu başındaki Dollar ($) işaretinden anlar ve bu işaretin içeriğini bilgisayarın belleğine, daha sonra kullanılmak üzere alır. Tekil değişken adları rakam ya da harf olabilir fakat alt çizgi(_) dışında bir işaretle isimlendirilemezler. Tekil değişken adları büyük ya da küçük harfle kullanılabilir fakat Perl büyük harf ile küçük harfi ayrı ayrı algılar yani perl için "Degisken" kelimesi ile "degisken" kelimesi aynı değildir. Değişken değeri rakam ise ya da başka bir değişken ise tırnak işareti (") kullanmaya gerek yoktur ama eğer değeri harf ise ya da içeriğinde harfler varsa değer verilirken tırnak işareti kullanılması gerekir.

    Örnek :

    #!/usr/bin/perl

    # degisken1.cgi


    print "Content-type:text/html\n\n";

    $isim = "Ayhan";
    $site = "http://www.acemiler.net";

    print "Merhaba, benim adım $isim, şu anda $site adresindesiniz.";








    Sadece $isim ve $site değişkenlerinin içerikleriyle oynayarak alttaki yazıyı değiştirebilirsiniz. Hata yapmamak için değişken adlarını küçük harfle, daha sonra hatırlayabileceğiniz basitlikte vermenizde fayda vardır.

    Ayrıca tekil değişkenin içeriği rakam ise tırnak işareti olmadan da değişkene değer atayabilirsiniz.

    Dizi (array) değişkenler;

    Dizi değişkenleri bir küme gibi görebilirsiniz. Tekil değişkenlerden farklı olarak içinde belli sayıda elemanlar vardır ve bu elemanlarla işlem yapabilirsiniz. (silebilirsiniz, düzenleyebilirsiniz, yeni eleman ekleyebilirsiniz.) Dizi değişkenler at (@) işareti ile başlarlar. İsimlendirme kuralları tekil değişken ile aynıdır. Harf, rakam ya da alt çizgi (_) ile isimlendirilmelidirler. Büyük küçük harf ayrımı söz konusudur.

    Dizi değişkenler elemanlardan oluşur dedik. Bu elemanları dizi içerisindeki sıralamasına göre tekil değişken olarak kullanabilirsiniz. Şu an belki anlamsız olarak görülebilir ama ileride veri dosyaları üzerinde çalışırken dizi değişkenleri çok kullanacaksınız. Perl saymaya c dilleri gibi 0'dan başlar ve mesela @dizi isimli bir dizi değişkenimiz varsa $dizi[0] şeklinde dizinin ilk elemanını, $dizi[3] şeklinde dizinin 4 numaralı elemanını kullanabilirsiniz.

    Örnek:


    #!/usr/bin/perl

    # degisken2.cgi

    print "Content-type:text/html\n\n";

    @dizi = ('ayhan','mail@acemiler.net','www.acemiler.net','c gi/Perl');

    $isim = $dizi[0];
    $mail = $dizi[1];
    $site = $dizi[2];
    $ilgi = $dizi[3];

    print "<html><body>";
    print "İsim : $isim <br>";
    print "Mail : $mail <br>";
    print "Site: $site <br>";
    print "İlgi alanları : $ilgi <br>";
    print "</body></html>";







    Örneğimizde bir dizi değişkenin nasıl atanacağını, içeriğinin nasıl ekrana yazdırılacağını gördünüz. Döngüler konusunda da dizi değişkenlerin döngü ile nasıl kolayca ekrana yazdırılabileceğini göreceğiz. Şimdilik dizi değişkenler hakkında bu kadar bilgi yeterli.

    İlişkili dizi (hash) değişkenler :

    İlişkili dizi değişkenin dizi değişkenden farkı birbiriyle ilişkili elemanlardan oluşuyor olmasıdır. İlişkili dizi değişkenlerde iki unsur vardır: anahtar (key) ve değer (value). Bir ilişkili dizin aynı adda iki anahtara sahip olamaz ama aynı adda birden fazla değer bulunabilir.

    %iliskili_dizi = ("anahtar1" => �deger1�
    "anahtar2" => �deger2�
    ...
    ...
    );



    İlişkili dizinlerin kullanım alanı dardır o yüzden sonraki derslerde daha çok dizi değişkenkleri (array)
    Splice ve Split fonksiyonu

    Split fonksiyonu :
    Bir önceki derste dizi değişkenleri görmüştük. Split fonksiyonu içeriğini bildiğimiz dizi ya da tekil değişken içeriğini istediğimiz gibi kullanabilmemize olanak verir. Daha çok dosya ile yapılan işlemlerde kullanılır. Üç argümanı vardır, genelde iki argüman kullanılır.

    "dizi yada tekil değişken" = split(/bölme karakteri/, bölünen değişken);

    Öncelikle şöyle bir değişkenimiz olsun:

    $isimler = "ali veli mustafa ismail hasan";

    Şimdi bu tekil değişkeni boşluk işaretinden bölelim ve dizi değişkene atayalım :

    @isim = split(/ /, $isimler);

    print "$isim[0];

    Örnek :

    #!/usr/bin/perl

    # split.cgi

    print "Content-type:text/html\n\n";

    $dizi = "ali|21|1980|samsun|lise";

    ($isim, $yas, $dtarihi, $dsehri, $mezuniyet) = split (/\|/, $dizi);


    print "<html><body bgcolor=\"#eeeeee\"><br>";
    print "<font face=\"verdana\" size=\"2\">";
    print "<b>İsim :</b> $isim<br>";
    print "<b>Yaş :</b> $yas<br>";
    print "<b>Doğum Tarihi :</b> $dtarihi<br>";
    print "<b>Doğduğu şehir :</b> $dsehri<br>";
    print "<b>Mezuniyet derecesi :</b> $mezuniyet<br>";
    print "</body></html>";







    Örnekte $dizi tekil değişkeninin içeriğini "|" karakterinden split() fonksiyonu yardımıyla bölüyoruz ve 4 ayrı değişkene atıyoruz. Daha sonra da bu değişkenleri teker teker ekrana yazdırıyoruz.

    Splice Fonksiyonu

    Splice fonksiyonunu kullanarak bir dizi değişkene eleman ekleme yada dizi değişkendeki belli bir elemanı silme işlemi yapabiliriz. Bu fonksiyonun 4 argümanı vardır: Dizi değişkenin adı, eklenecek (ya da silinecek) elemanın sıra numarası, çıkartılacak eleman sayısı, eklenecek elemanın içeriği. Kullanımı şu şekildedir:

    @dizi_degisken = (0, 1, 2, 3);

    splice (@dizi_degisken, 4, 0, (4));

    print "$dizi_degisken[4]";

    Bu örnekte dizi değişkendeki hiç bir üyeyi atmadan listenin 4. sırasına (bu arada perl'ün saymaya sıfırdan başladığını unutmadınız umarım) "4" elemanını ekledik. Eğer isterseniz hiç bir şey eklemeden belli bir üyeyi de silebilirsiniz:

    splice (@dizi_degisken, 2, 1, ());

    Böylece dizideki "2" elemanı silindi.

    Splice fonksiyonu da en çok dosya işlemlerinde veritabanındaki belli bir kaydın düzenlenmesi ya da silinmesi için kullanılır.

    Örnek :



    #!/usr/bin/perl

    # splice.cgi

    print "Content-type:text/html\n\n";

    @dizi = ("sıfır","bir","iki","üç","dört","beş");

    print "<html><body>";
    print "Dizinin şu anki elemanları:@dizi<br><br>";

    splice(@dizi, 3, 1, (333));

    print "Dizinin 3. elemanının değişmiş hali: @dizi<br><br>";

    splice(@dizi, 3, 1, ());

    print "Dizinin 3. elemanının silinmiş hali: @dizi<br><br>";

    print "</body></html>";






    Gelen Veri form verileri

    Form verilerinin kullanılması :
    Giriş yazısında belirttiğim gibi CGI ile interaktif sayfalar oluşturabilir, formdan gelen verileri kullanarak ziyaretcilerden bilgi ya da görüş ababilirsiniz. Peki html içindeki formdan gelen verileri nasıl kullanacağız? Bir html sayfasındaki form içine birşeyler yazılıp "submit" butonuna tıklanınca formun "action" hanesinde yazılı olan dosyaya içine yazılan bilgileri teslim eder. Bu bilgileri alan dosya da programlaması nasıl yapılmışsa ona göre bu bilgileri kullanır, kaydeder, mail ile gönderir ya da ekrana yazar.

    HTML bildiğinizi varsayarak form etiketinin unsurları ve içeriği konularına girmiyorum. Form ile html üzerinden 2 türlü veri gönderilebilir: GET ve POST. Get metodu ile daha çok kısa veriler gönderilir ve programın yönlendirilmesinde kullanılır. Uzun bilgiler de gönderilebilse de veri kaybı riski yüzünden güvensizdir. Get metodunda veriler $ENV{QUERY_STRING}; çevre değişkeninde saklanır ve programa teslim edilir. Ayrıca Post metodu ile gönderilen veriler browser adres çubuğunda görüntülenir. POST metodu ise veriyi bir paket halinde $ENV{CONTENT_LENGTH}; çevre değişkeninde depolar ve programa teslim eder. Browser adres hanesinde görüntülenemez, veri kaybı riski yoktur ve büyük veriler için kullanılabilir. Ayrıca formdan gelen verinin hangi metodla yollandığı $ENV{REQUEST_METHOD}; çevre değişkeninde saklanır.

    İsim ve soyisim bölümlerinden oluşan bir form içeriği programa şu şekilde gönderilir:

    isim=formiçeriği&soyisim=formiçeriği

    Program gelen veriyi önce "&" işaretinden bölerek dizi değişkene, daha sonra da "=" işaretinden bölerek dizi değişkene atar.

    Formdan gönderilen veriler 2 türlü değişkene atanıp kullanılabilir.

    Klasik Yöntem :

    Bu yöntemde herhangi bir modül kullanılmadan gelen veri değişkene atanır. Bu yöntemle verileri atarken verinin gönderildiği metodu bilmek gereklidir. GET ve POST metodu ile gönderilen veriler ayrı ayrı çevre değişkenlerinde tutulduklarından farklı kodlarla ayrıştırılır. Ayrıca gelen veri değişkene atanırken bazı düzenlemeler de yapılması gerekir.

    1) Post metodu ile gönderilen veriler:

    Post metodu ile gönderilen veriler $ENV{'CONTENT_LENGTH'} çevre değişkeni içinde depolanıp programa teslim edilirler. Bu veriler şu şekilde bir kod kullanılarak açılır:


    read(STDIN, $depo, $ENV{'CONTENT_LENGTH'});

    @dizidegisken = split(/&/, $depo);

    foreach $duzenle (@dizidegisken) {
    ($isim , $deger) = split(/=/, $duzenle);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
    $deger =~s///g;

    $form{$isim} = $deger;
    }

    Bu işlemlerden sonra mesela <input type=text name=isim> şeklinde gönderilen bir veri $form{isim] şeklinde kullanılabilir.

    2) Get metodu ile gönderilen veriler :

    GET metodu ile gönderin veriler $ENV{'QUERY_STRING'} çevre değişkeni içinde depolanıp programa teslim edilir. Bu veriler şu şekilde değişkene atanabilirler :
    @girdi=split(/\&/,$ENV{'QUERY_STRING'});

    foreach $depo (@girdi) {

    ($isim,$deger) = split(/=/,$depo);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;

    $form{$isim} = $deger;
    }

    Bu işlemlerden sonra az önceki örnekteki gibi "name" bölümü "isim" olan inputdan gelen veri $form{isim} şeklinde kullanılabilir.


    Eğer bir program içerisinde hem POST hem de GET metodunda veriler gönderilmişse şöyle bir kod kullanılabilir:


    @dizidegisken = split (/&/, $ENV{'QUERY_STRING'});

    foreach $get(@dizidegisken) {
    ($isim, $deger) = split (/=/, $get);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
    $deger =~ tr/ //s;
    $form{$isim} = $deger;
    }

    read(STDIN, $depo, $ENV{'CONTENT_LENGTH'});

    @dizidegisken = split(/&/, $depo);

    foreach $post (@dizidegisken) {
    ($isim , $deger) = split(/=/, $post);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
    $form{$isim} = $deger;
    }

    Bu kodlardan sonra formdan gelen her iki metoddaki veriler de $form{isim} şeklinde değişkene atanıp kullanılabilirler.

    Bu bilgiler doğrultusunda bir örnek program yapalım. Program iki veri türüyle de aynı bilgileri gönderecek (böylece iki metod arasındaki farkı ve benzerlikleri görebileceğiz) formlardan oluşacak, bu formlar kendi kendine veri gönderecek ve bu verileri açıp ekrana yazdıracak:


    #!/usr/bin/perl

    # parse1.cgi

    print "Content-type:text/html\n\n";

    @dizidegisken = split (/&/, $ENV{'QUERY_STRING'});

    foreach $get(@dizidegisken) {
    ($isim, $deger) = split (/=/, $get);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
    $deger =~ tr/ //s;
    $form{$isim} = $deger;
    }

    read(STDIN, $depo, $ENV{'CONTENT_LENGTH'});

    @dizidegisken = split(/&/, $depo);

    foreach $post (@dizidegisken) {
    ($isim , $deger) = split(/=/, $post);
    $deger =~ tr/+/ /;
    $deger =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
    $form{$isim} = $deger;
    }


    $isim = $form{isim};
    $soyad = $form{soyad};

    $sanatci = $form{sanatci};
    $sarki = $form{sarki};


    print "<h3>Gönderdiğiniz veriler: </h3><br><br>";
    print "<b>İsim : </b>$isim<br>";
    print "<b>Soyad : </b>$soyad<br>";
    print "<b>Şarkıcı : </b>$sanatci<br>";
    print "<b>Şarkı : </b>$sarki<br><br><br>";

    print "<h3>Formlar :</h3><hr>";
    print "<b>GET metoduyla :</b><br>";
    print "<form action=parse1.cgi method=get>";
    print "İsminiz : <input type=text name=isim><br>";
    print "Soyad : <input type=text name=soyad><br>";
    print "Sevdiğiniz Sanatcı : <input type=text name=sanatci><br>";
    print "Sevdiğiniz şarkı : <input type=text name=sarki><br>";
    print "<input type=submit value=Gönder></form>";
    print "<hr><b> POST metoduyla :</b><br>";
    print "<form action=parse1.cgi method=post>";
    print "İsminiz : <input type=text name=isim><br>";
    print "Soyad : <input type=text name=soyad><br>";
    print "Sevdiğiniz Sanatcı : <input type=text name=sanatci><br>";
    print "Sevdiğiniz şarkı : <input type=text name=sarki><br>";
    print "<input type=submit value=Gönder>";
    print "</form></body></html>";




    Klasik metod iyidir, herhangi bir modüle ihtiyaç duymaz, her ortamda çalışır. Ama modül kullanarak yukarıdaki işlemi daha basit ve kolay hale getirebiliriz.

    CGI.pm modülü kullanarak form verilerini değişkene atama :

    Modüller perl'de bazı işleri daha kolay ve kısa kodlarla yapmamıza olanak veren paketlerdir. Modüller konusuna ilerde değinileceği için bu derste sadece CGI.pm modülünün kullanımını açıklamaya çalışacağım. CGI.pm modülü kullanarak gelen verileri açıp değişkene atamak için öncelikle dosyanın başına (shebang'dan sonra) şu kodu eklememiz gerekiyor:

    use CGI qw(:standard);

    Bu kodu ekleyerek CGI.pm modülünün bize verdiği kolaylıkları kullanabiliriz. Daha sonra formdan gelen veriyi kullanabilmek için yeni bir CGI nesnesi oluşturmalıyız :

    $query = new CGI;

    CGI.pm modülünü kullanarak mesela "name" bölümü "isim" olan bir form verisini açmak için şöyle bir kod kullanmamız yeterlidir:

    $isim = $query -> param('isim');

    CGI.pm modülü kullanıldığında formdan gelen verinin POST ya da GET metodu ile gönderilmesinin bir önemi yoktur. İki türde aynı şekilde açılıp değişkene atanabilir.

    Buna göre az önceki örneği CGI.pm modülü kullanarak şu şekilde yapabiliriz:


    #!/usr/bin/perl
    # parse2.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $isim = $query -> param('isim');
    $soyad = $query -> param('soyad');

    $sanatci = $query -> param('sanatci');
    $sarki = $query -> param('sarki');

    print "<html><body>";

    print "<h3>Gönderdiğiniz veriler: </h3><br><br>";
    print "<b>İsim : </b>$isim<br>";
    print "<b>Soyad : </b>$soyad<br>";
    print "<b>Şarkıcı : </b>$sanatci<br>";
    print "<b>Şarkı : </b>$sarki<br><br><br>";
    print "<h3>Formlar :</h3><hr>";
    print "<b>GET metoduyla :</b><br>";
    print "<form action=parse2.cgi method=get>";
    print "İsminiz : <input type=text name=isim><br>";
    print "Soyad : <input type=text name=soyad><br>";
    print "Sevdiğiniz Sanatcı : <input type=text name=sanatci><br>";
    print "Sevdiğiniz şarkı : <input type=text name=sarki><br>";
    print "<input type=submit value=Gönder></form>";
    print "<hr><b> POST metoduyla :</b><br>";
    print "<form action=parse2.cgi method=post>";
    print "İsminiz : <input type=text name=isim><br>";
    print "Soyad : <input type=text name=soyad><br>";
    print "Sevdiğiniz Sanatcı : <input type=text name=sanatci><br>";
    print "Sevdiğiniz şarkı : <input type=text name=sarki><br>";
    print "<input type=submit value=Gönder>";
    print "</form></body></html>";





    Gördüğünüz gibi yukarıda yaklaşık 20 satır kodun yaptığı işi modül kullanarak 7 satırda hallettik. Günümüzde CGI.pm modülü CGI desteği olan hemen hemen her server'da desteklenir ve gelişmiş perl programları da form verilerini bu yolla açarak kullanırlar. Bundan sonraki örneklerimizde de basitliği ve anlaşılabilirliği açısından CGI.pm modülü kullanılarak yapılacak.

    Konu zeet06 tarafından (08.11.08 Saat 18:45 ) değiştirilmiştir.
    KaSSaS bunu beğendi.

  2. #2
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb

    Çevre Değişkenleri

    Çevre Değişkenleri :
    Bir *.cgi dosyası ya da *.pl dosyası çalıştırıldığı anda (formdan veri gönderilsin veya gönderilmesin) istemci bilgisayar ya da bulunduğu çevre hakkında bir takım bilgiler toplar ve bu bilgileri %ENV ilişkili dizi değişkenine, belli anahtarlarla atar. Daha sonra bu değişkenin elemanları kullanılabilir. Mesela siteye gelen ziyaretcinin IP numarası $ENV{REMOTE_ADDR} şeklinde belirlenir. Sadece IP adresi değil istemcinin browser türü, programın bulunduğu server'a ait bilgiler (path, server yazılımının türü, versiyonu, perl yolu) çevre değişkenlerinde gerektiğinde kullanılmak üzere saklanır. Bazı çevre değişkenleri şunlardır:


    REMOTE_ADDR : Ziyaretci bilgisayarın IP adresi.
    REMOTE_HOST : Ziyaretci bilgisayarın adı (ya da ıp adresi).
    HTTP_ACCEPT : Browser'ın kabul ettiği MIME türleri.
    HTTP_USER_AGENT : Browser'ın türü.
    HTTP_REFERER : Referans veren sayfa.
    REQUEST_METHOD : Form verilerinin gönderilme metodu (Post ya da Get).
    CONTENT_LENGTH : Post metoduyla gönderilen verilerin boyutu.
    QUERY_STRING : Get metodu ile gelen bilgiler.
    PATH_INFO : Programın çalıştığı dizinin göreli yolu.
    PATH_TRANSLATED : Programın çalıştığı dizinin disk üzerindeki yolu.
    SERVER_SOWFTWARE : Sunucu bilgisayarın server yazılımı.
    SERVER_VERSION : Sunucu bilgisayardaki server yazılımının versiyonu.
    SCRIPT_PATH : Programın çalıştığı dizinin tam yolu.
    SERVER_PORT : Sunucu bilgisayarın o anda kullandığı port numarası.


    Çevre değişkenleri program çalıştığı anda %ENV ilişkili dizi değişkenine atandığı için kullanmak için herhangi bir ek işlem yapmanıza gerek yoktur. Direk $ENV{'ANAHTAR'} şeklinde kullanabilirsiniz.

    Örnek :

    #!/usr/bin/perl

    # cevre.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";
    print "IP numaranız: <b>$ENV{'REMOTE_ADDR'}</b><br>";
    print "Browser'ınızın türü: <b>$ENV{'HTTP_USER_AGENT'}</b><br>";
    print "Server yazılımınız: <b>$ENV{'SERVER_SOFTWARE'}</b><br>";
    print "Server versiyonu : <b>$ENV{'SERVER_VERSION'}</b><br>";
    print "Programın tam yolu: <b>$ENV{'SCRIPT_PATH'}</b><br>";

    print "</body></html>";





    Çevre değişkenleri bir ilişkili dizide tutulur demiştik. Bir CGI dosyasına gelen tüm çevre değişkenlerini yani
    %ENV ilişkili dizi değişkeninin içeriğini şu şekilde görebiliriz :

    #!/usr/bin/perl

    # cevre2.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";

    foreach $env_var (keys %ENV)

    {

    print "<B>$env_var</B> = $ENV{$env_var}<BR>\n";

    }

    print "</body></html>";
    Perl ile döngüler

    Perl Dilinde Döngüler :
    Her programlama dili gibi Perl de döngülerle çalışır. Gelişmiş CGI programları onlarca döngüden (loop) oluşur. Döngü bir şart gerçekleşene kadar aynı işlemin tekrar etmesi demektir. Bu şart veri dosyasının sonuçlanması ya da bir dizi değişkenin içindeki tüm elemanların teker teker sayılması olabileceği gibi her döngüde bir arttırılan değişkenin belli bir rakama gelmesi yani döngünün belli sayıda dönmesi de olabilir. Her programlama dilinde olduğu gibi Perl'de de döngüleri öğrenmek ve kullanmak zordur. O yüzden bol bol pratik yapmalı, kod yazmalı ve döngüleri farklı şartlar altında kullanmalısınız ama önce tanışmanız gereken bir kavram var:

    Sonsuz Döngü :

    Sonsuz döngü, döngünün sonuçlanması için gereken şartın meydana gelmemesi yani döngünün sonsuz defa dönmeye başlamasıdır. Programcıların en çok yaptığı hatalardan biridir. Eğer içinde döngü geçen bir programı çalıştırmaya çalıştığınızda sayfa çok yavaş yükleniyorsa, işlemciden aşırı şekilde ses geliyorsa ve mouse'da takılma oluyorsa sonsuz döngüye girdiniz demektir, ctrl+alt+del e basıp çıkan pencerede Perl'ü seçin ve "Görevi sonlandır" butonuna basın. Browser'ı kapatsanız bile döngü devam edebilir. Eğer bir dosyaya döngü ile birşeyler yazdırıyorsanız ve program sonsuz döngüye girmişse harddisk'iniz birkaç dakikada (belki de daha az bir sürede) tamamen dolabilir. Bu yüzden döngüleri kullanırken çok dikkatli olmalısınız.

    Foreach Döngüsü :

    Foreach döngüsü bir dizi değişken ya da eldeki belli bir veri sonuçlanıncaya kadar döngü yapar.

    Örnek :

    #!/usr/bin/perl

    # dongu1.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";

    @dizi = ("ahmet", "mehmet", "suleyman", "murtaza", "salih", "ayşe", "hakan", "özlem");


    foreach $dongu (@dizi) {

    print "Döngünün şimdiki üyesi : $dongu <br>";

    }


    print "</body></html>";



    Burada kısaca yaptığımız şu: önce "dizi" isminde bir dizi değişken oluşturduk, daha sonra "dizi" isimli dizi değişken için "foreach" döngüsü başlattık. Bu döngü dizi değişkenin içindeki elemanlar sonuçlanıncaya kadar devam eder ve $dongu isimli değişken için döngü içinde yapılan işlemler dizi değişkenin içindeki tüm elemanlar için döngü süresince uygulanır. Biz örneğimizde dizi değişken içindeki tüm elemanları sırayla ekrana yazdırdık. Döngüdeki sıralamaya dikkat edin.

    Foreach döngüsü genel olarak dosya okutup dosya içeriğini dizi değişkene atadıktan sonra bu dosya elemanlarını teker teker ekrana yazdırmakta kullanılsa da farklı şekilde de kullanılabilir. Farklı kullanıma bir örnek :

    #!/usr/bin/perl

    # dongu2.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";

    foreach $dongu (1..20) {

    print "Döngünün şimdiki üyesi : $dongu <br>";

    }



    print "</body></html>";






    Bu örnekte de 1 ile 20 arasında döngü oluşturduk ve bu aralıktaki her rakam için teker teker bir işlem (ekrana yazdırma) yaptık.

    While Döngüsü :

    While döngüsü de hemen hemen aynı mantıkla çalışır. Döngü oluşur ve döngü bitimine kadar döngü içinde yazan eylemler teker teker tekrar eder fakat Foreach'dan farkı bu şartı kendimiz belirlememizdir. Aşağıdaki örnekte biraz html ile Perl'ü karıştırıp önce sayaç isimli bir tekil değişken oluşturup değerini "1" yapıyoruz ve sayaç değeri 5 olana kadar döngüyü tekrar ediyoruz. Döngü her tekrar edişinde $sayac tekil değişkeninin değerini bir arttırıyoruz. Eğer $sayac değişkeni tanımlanmasaydı ya da her döngüde bir arttırılmasaydı sonsuz döngüye düşerdik...


    #!/usr/bin/perl

    # dongu3.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";

    $sayac = 1;

    while ($sayac <= 5) {

    print "<h$sayac>Sayaç değeri: $sayac</h$sayac>";

    $sayac++;

    }

    print "</body></html>";






    For Döngüsü :

    For döngüsü de While döngüsüyle hemen hemen aynı işlevi görür fakat argümanlar biraz değişiktir. Yukarıda While ile yaptığımız örneği For döngüsü ile yapalım :



    #!/usr/bin/perl

    # dongu3.cgi

    print "Content-type:text/html\n\n";

    print "<html><body>";

    for ($sayac = 1; $sayac <= 5; $sayac+=1) {

    print "<h$sayac>Sayaç değeri: $sayac</h$sayac>";

    }

    print "</body></html>";

    Bu kodlar yukarıda verdiğimiz While döngüsü örneğiyle aynı işlevi görür.
    Mantıksal sınama

    Perl'de Mantıksal Sınama :
    Perl ile formdan gelen ya da bir şekilde elde ettiğimiz veriyi mantıksal sınamaya tabi tutabilir ve programı buna göre yönlendirebiliriz. Perl'de mantıksal sınamalar şu şekildedir:

    Sayısal değerlerde mantıksal sınama :


    İşlemAnlamıx > y x büyüktür y'den x < y x küçüktür y'den x >= y x büyük eşittir y'ye x <= y x küçük eşittir y'ye x == y x eşittir y'ye x != y x eşit değildir y'ye


    Sayısal olmayan değerlerde mantıksal sınama:


    İşlemAnlamıa eq b a eşittir b'ye a ne b a eşit değildir b'ye a lt b a küçüktür b'den a gt b a büyüktür b'den a le b a küçük eşittir b'ye a ge b a büyük eşittir b'ye


    Buna göre perl'ile bir veri ya da değişken üzerinde mantıksal sınama yapmak için bu verinin ya da değişkenin içeriğinin sayısal olup olmadığını bilmemiz gerekiyor.

    Mantıksal sınama if, elsif, else fonksiyonları :

    Yukarıda sayısal değerlerde ve sayısal olmayan değerlerde (string) karşılaştırma operatörlerini gördünüz ama ne işe yaradıklarını bilmiyorsunuz. Bu operatörler perl'de karşılaştırma yapmaya olanak verir ve bunu da if(), elsif() ve else() komutlarıyla sağlarız. Kullanımı şu şekildedir:

    if (koşul) {
    koşul sonunda yapılacak işlem
    }
    elsif(koşul) {
    koşul sonunda yapılacak işlem
    }
    else {
    bu iki (ya da daha fazla) koşulun gerçekleşmemesi durumunda yapılacak işlem
    }

    Buna göre iki rakamı form vasıtasıyla programa gönderelim, program bize bu iki rakamı karşılaştırıp sonucunu ekrana yazsın :



    #!/usr/bin/perl

    # if1.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $ilksayi = $query -> param('ilksayi');
    $sonsayi = $query -> param('sonsayi');

    print "<html><body>";

    if ($ilksayi ne "" or $sonsayi ne "") {

    if ($ilksayi == $sonsayi) {

    print "ilksayı($ilksayi) ile ikinci sayı($sonsayi) eşit!";

    }

    elsif ($ilksayi != $sonsayi) {

    print "ilksayı ($ilksayi) ile ikinci sayı($sonsayi) eşit değil!";

    }
    }





    print "<br>";
    print "<form action=if1.cgi method=post>";
    print "Birinci sayı: <input type=text name=ilksayi><br>";
    print "İkinci sayı: <input type=text name=sonsayi>";
    print "<input type=submit value=Karşılaştır>";


    print "</body></html>";








    İlk "if" karşılaştırması dikkatinizi çekti mi? Bu ilk karşılaştırma sayesinde eğer formdan veri gelmemişse sadece form görünüyor, formdan veri gelmişse karşılaştırma yapılıyor ve altında yine form gösteriliyor böylece programın saçmalamasını önlüyoruz.

    Aynı şeyi bir de sayısal olmayan değerlerle, yani harflerle yapalım. Mesela formdan gönderilen veriler bizim ismimize eşitse ekrana "Senin isminle benim ismim aynı, biz adaşız" yazdıralım, değilse "isimlerimiz aynı değil, biz adaş değiliz" yazdıralım :


    #!/usr/bin/perl

    # if2.cgi

    $benim_ismim = "hakan";

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $isim = $query -> param('isim');

    print "<html><body>";

    if ($isim ne "") {

    if ($isim eq $benim_ismim) {

    print "Bizim isimlerimiz aynı, biz adaşız!";

    }

    elsif ($isim ne $benim_ismim) {

    print "İsimlerimiz aynı değil, biz adaş değiliz";

    }

    }



    Yukarıdaki örnekte $benim_ismim değişkenini kendi adınızla ya da başka adlarla değiştirerek sınama yapabilirsiniz.
    Matemetiksel işlemler

    Perl'de matematiksel işlemler :
    Matematik ile aranız nasıl bilmiyorum ama gerçek CGI programları yazmaya başladığınızda programlarınızın içinde mutlaka matematiksel işlemler yapmak zorunda kalacaksınız. Bu işlemler çok karmaşık işlemler olabileceği gibi değişkenleri toplama, çıkarma, döngü sırasında bir değer arttırma şeklinde de olabilir. Bu derste perl ile yapabileceğimiz matematiksel işlemleri ele alacağız.

    Perl ile dört işlem :

    Perl ile sayıları ya da sayı içerikli değişkenleri toplayabilir, çıkarabilir, bölebilir ya da çarpabiliriz. Örneğin elimizde şu değişkenler var :

    $a = 1;
    $b = 2;
    $c = 3;
    $d = 4;

    Önce $a ile $b'yi toplayalım :

    $sonuc = $a + $b;

    print $sonuc;

    Bu kod ekrana $sonuc değişkenin değerini yani "3" yazdıracaktır. $b değişkeninden $a değişkenini çıkarmak için ise şöyle bir kod yazmamız gerekir :

    $sonuc = $b - $a;

    print $sonuc;

    Bu kod da ekrana "1" yazdıracaktır. Çarpma işlemi ise şu şekilde :

    $sonuc = $b * $d;

    print $sonuc;

    Bu kod da $b değişkeni ile $d değişkenlerinin değerlerini çarpıp sonucu $sonuc değişkenine atar ve ekrana "8" yazdırır. Bölme işlemi ise şu şekilde :

    $sonuc = $d / $b;

    print $sonuc;

    Bu kod da $d değişkeninin değerini $b değişkeninin değerine böler (4 / 2), sonucu $sonuc değişkenine atar ve ekrana yazdırır. Eğer birden fazla işlem yapmak istiyorsak, mesela önce $a, $b, ve $c değişkenlerini toplayıp sonuçtan $d değişkenini çıkarmak istiyorsak şu şekilde bir kod kullanmamız gerekir :

    $sonuc = ($a + $b + $c) - $d;

    print $sonuc;

    Bu kodla program önce $a, $b ve $c değişkenlerinin değerlerini toplar, sonra çıkan sonuçtan $d değişkeninin değerini çıkarır ve sonucu (6-4 = 2) ekrana yazar.

    Dört işlem için bu kadar örnek fazla bile. Şimdi öğrendiğimiz bilgilerden daha "işe yarar" bir örnek yapalım. Örneğimiz formdan gelen iki sayı üzerinde işlem yapsın. Bu işlem yine ziyaretcinin (yani bizim) seçtiğimiz işlem olsun. Yani kısaca dört işlem yapabilen basit bir hesap makinası yapalım :


    #!/usr/bin/perl

    # hesapla.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $sayi1 = $query -> param('sayi1');
    $sayi2 = $query -> param('sayi2');
    $islem = $query -> param('islem');

    print "<html><body>";

    if ($islem ne "") {

    if ($islem eq "topla") {

    $sonuc = $sayi1 + $sayi2;
    print "İşlem sonucu : $sonuc";

    }

    elsif ($islem eq "cikar") {

    $sonuc = $sayi1 - $sayi2;
    print "İşlem Sonucu : $sonuc";

    }

    elsif ($islem eq "bol") {

    $sonuc = $sayi1 / $sayi2;
    print "İşlem Sonucu : $sonuc";

    }

    elsif ($islem eq "carp") {

    $sonuc = $sayi1 * $sayi2;
    print "İşlem Sonucu : $sonuc";

    }
    }

    print "<form action=hesapla.cgi method=post>";
    print "<input type=text name=sayi1> sayısı ile ";
    print "<input type=text name=sayi2> sayısını ";
    print "<select name=islem>";
    print "<option value=topla>Topla<br>";
    print "<option value=cikar>Çıkar<br>";
    print "<option value=bol>Böl<br>";
    print "<option value=carp>Çarp<br>";
    print "</select>";
    print "<input type=submit value=YAP!>";
    print "</form>";

    print "</body></html>";








    Perl ile ileri matematik işlemleri de yapabilirsiniz. Mesela :

    $sayi = 12;

    $karekok = sqrt($sayi);

    print $karekok;

    Bu kod sqrt() fonksiyonu ile $sayi değişkeninin değerini $karekok değişkeninin değerine atar ve ekrana 12'nin karekökünü yazdırır.

    $sayi = 12;

    $log = log($sayi);

    print $log;

    Bu kod log() fonksiyonunu kullanarak $sayi değişkeninin logaritmasını alır, $log değişkenine atar ve ekrana yazdırır. Aynı şekilde exp() fonksiyonu ile sayının exponensiyelini, int() fonksiyonu ile sayının integerini, abs() fonksiyonu ile sayının mutlak değerini bulabilirsiniz.

    Dosya işlemleri

    Perl ile dosya işlemleri :
    Perl sunucu tarafında çalışan bir dildir dedik. Perl vasıtası ile sunucu tarafında yani web alanında dosya açabilir, açtığımız dosyaya kayıt yapabilir -ya da ekleme yapabilir- , dosyadan belli bir kaydı silebilir ya da dosyayı silebiliriz. Perl'in bize sağladığı bu olanağı kullanarak açtığımız herhangi bir dosyayı veritabanı olarak kullanabiliriz. Perl ile server'da varolan ya da varolmayan bir dosyayı open() fonksiyonu kullanarak açarız. open() fonksiyonu ile dosyayı açtıktan sonra dosyayı bir "file handle" olarak tanımlar ve dosya üzerinde işlem yapıp dosyayı kapatana kadar da bu "file handle" ı kullanırız.

    Yeni dosya oluşturma ve kayıt yapma :

    Dosyayı açtıktan sonra formdan gelen ya da herhangi bir şekilde elde ettiğimiz veriyi istediğimiz formatta dosyaya print "..."; şeklinde yazdırabiliriz. Bunun için eğer dosyaya yazarken eski bilgilerin üzerine yazılmasını, eski bilgilerin silinmesini istiyorsanız open fonksiyonu şu şekilde kullanılmalıdır:

    open (HANDLE, ">dosya.dat");

    HANDLE yazan yer "file handle" dediğimiz, daha sonra dosya üzerinde işlem yaparken kullanacağımız takma isimdir. Dosyalara isim verirken Türkce karakter kullanılmaz, küçük harf kullanmanın bir sakıncası olmamasına karşın genelde büyük harf kullanılır. Dediğim gibi dosyaya yazarken eski bilgilerin silinmesini istiyorsanız dosyayı açarken dosyadan önce bir tane büyüktür (>) işareti kullanmanız gereklidir. Eğer kayıt yaparken eski dosyadaki bilgileri muhafaza etmek istiyorsanız dosya adından önce iki tane büyüktür (>>) işareti kullanmanız gerekir.

    open (HANDLE, ">>dosya.dat");

    Bu şekilde dosyaya yazdırdığınız bilgiler eski bilgilerin üzerine değil, bir alt satırına kaydedilir.

    Örnek :


    #!/usr/bin/perl

    # dosya1.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $isim = $query -> param('isim');
    $soyad = $query -> param('soyad');

    if ($isim eq "" or $soyad eq "") {

    print "<html><body>";
    print "<br>";
    print "<form action=dosya1.cgi method=post>";
    print "Lütfen isminizi yazın: <input type=text name=isim><br>";
    print "Lütfen soyadınızı yazın: <input type=text name=soyad><br>";
    print "<input type=submit value=Yolla!></form></body></html>";

    exit;

    }

    open (DOSYA, ">>veri.txt");
    print DOSYA "$isim|$soyad\n";
    close (DOSYA);

    print "Verdiğiniz bilgiler başarıyla <a href=veri.txt>veritabanına</a> kaydedildi.";




    Örnekte isim ve soyad isteyen, verildiğinde bu isim ve soyadı "|" karakteri ile ayırıp dosyaya kaydeden bir program yaptık. Program her "Yolla" butonuna bastığınızda gönderdiğiniz isim ve soyadı programla aynı klasördeki "veri.txt" dosyasına kaydedecek, eğer böyle bir dosya yoksa oluşturup öyle kaydedecektir. Daha sonra bu veritabanını "|" karakterinden bölerek ekrana yazdırabiliriz. Eğer dosyayı açarken iki büyüktür (>>) yerine sadece bir tane kullansaydık program her seferinde veri tabanına sadece bir tane kayıt yapardı.

    Dosya açıp dosya içeriğini ekrana yazdırma :

    Daha önce kayıt yapılmış bir dosya içeriğinin ekrana yazdırılması için şu işlemler yapılır: önce open() fonksiyonu kullanılarak dosya açılır, dosya içeriği bir değişkene (tek satırsa tekil, birden fazla satırsa dizi) atanır, daha sonra close () fonksiyonu ile açılan dosya kapatılır, bu dizi değişken direk print "@dizi"; şeklinde ya da bir döngü kullanılarak ekrana yazdırılır. Dosya açılırken dosya adından önce hiç işaret kullanılmaz ya da bir tane küçüktür (<) işareti kullanılır. Dizi değişken ekrana yazdırılırken veri dosyası içeriğine göre belli yerlerden (örneğimizde "|" karakterinden) split () fonksiyonu yardımıyla bölüm değişkene atanabilir.

    Örnek :


    #!/usr/bin/perl

    # dosya2.cgi

    print "Content-type:text/html\n\n";

    open (DOSYA, "veri.txt");
    @veriler = <DOSYA>;
    close (DOSYA);

    print "<b>Veritabanı içeriği</b><br><br>";

    print "<b>İsim - Soyad</b><br>";

    foreach $dongu (@veriler) {
    ($isim, $soyad) = split (/\|/, $dongu);
    print "$isim - $soyad<br>";

    }





    Örnekte bir öneki örnekte oluşturduğumuz veritabanı dosyasını açtık, @veriler dizi değişkenine atadık, dizi değişken için foreach döngüsü oluşturduk, döngü boyunca satırları split () fonksiyonu ile "|" karakterinden bölüp $isim ve $soyad adlı değişkenlere atadık ve bu değişkenleri teker teker ekrana yazdırdık.
    Alt Programlar

    Alt programlar :

    Programlarınızı yazarken dosya içerisinde tanımlanmış alt programları devreye sokarak program kodlarınızın daha anlaşılır, basit ve pratik olmasını sağlayabilirsiniz. Alt programlar and (&) işareti ile sembolize edilir ve sub isim {......} şeklinde tanımlanır. Ayrıca tanımlanmış bir alt programı başka bir dosyadan ileride göreceğimiz "require "dosya"; şeklinde de çağırabilirsiniz.

    Örnek :


    #!/usr/bin/perl

    # altprogram.cgi

    print "Content-type:text/html\n\n";

    print "<b>Alt program :</b><br>";

    &altprogram;

    print "bu yazı alt program isminden sonra yazıldığı için alt programın içerisindeki yazılardan
    sonra ekrana bastırılacaktır";

    exit;

    sub altprogram {

    print "Bu yazı alt program içerisinde yazılmaktadır.<br>";

    print "Perl yorumlayıcısı \& işareti ile başlayan bir satır görünce dosya içerisinde
    o isme ait tanımlanmış bir alt program arar, o programın içerisindeki kodları uygular,
    daha sonra \& ile başlayan satırdan sonra altındaki satırları uygulamaya başlar.<br><br>";

    }









    Alt programları kullanarak uzun ve karışık kodları daha basit ve anlaşılabilir hale getirebilirsiniz

    Bul ve değiştir

    Bulma ve değiştirme :

    Perl ile herhangi bir tekil değişken içeriğinde (cgi dosyası dahilinde atanmış tekil değişken, veri dosyasından aldığımız bilgi, formdan gelen bilgi...) isteğe bağlı olarak değiştirilme yapılabilir ya da belli karakterler ya da karakter toplulukları silinebilir. Mesela bir ziyaretci defteri yazıyorsanız bazı karakterlerin kullanılmamasını ya da sansürlenmesini sağlayabilirsiniz ya da güvenlik açısından bazı kodların kullanılmasını engelleyebilirsiniz. Fonksiyonun kullanımı şu şekildedir:

    $tekil_degisken =~ s/bulunacak/değiştirilecek/g;

    Eğer değiştirilecek karakterler içerisinde html unsuru bulunuyorsa /g; yerine satır /isg; şeklinde bitmelidir.

    $tekil_degisken =~ s/\[kalinyazi]/\

    #!/usr/bin/perl

    # buldegistir.cgi

    print "Content-type:text/html\n\n";

    use CGI qw(:standard);

    $query = new CGI;

    $bul = $query -> param('bul');
    $degistir = $query -> param('degistir');
    $metin = $query -> param('metin');

    if ($bul ne "" or $degistir ne "") {

    $metin =~ s/$bul/$degistir/g;

    print "Gönderdiğiniz metindeki <b>\"$bul\"</b> karakter(ler)i ";
    print "<b>\"$degistir\"</b> karakter(ler)i ile değiştirildi.<br><br>";
    print "Metnin değişmiş hali:<br><br>";
    print "$metin<br><br>";

    }

    print "<html><body><br>";
    print "<form action=buldegistir.cgi method=post>";
    print "Buraya metni girin :<br>";
    print "<textarea name=metin cols=60 rows=7></textarea><br><br>";
    print "Metin içerisinde <input type=text name=bul size=10> ";
    print "geçen yerleri <input type=text name=degistir size=10> yazısı ile ";
    print "<input type=submit value=Değiştir!>";
    print "</form>";
    print "</body></html>";




    Form gönderilmeden önce :





    Form gönderilip çevirme işlemi yapıldıktan sonra :





    Bu fonksiyonun kullanım alanı çok geniştir. Formlarda, mesaj tahtalarında ya da ziyaretci defterinde filtreler, özel kod kullanımı hatta şu sırıtan kafalar (smiley'ler ) bu fonksiyon sayesinde kullanılabilir. Bu fonksiyon sadece tekil değişkenlerde uygulanabilir, dizi değişkende bu fonksiyonu uygulamak için döngü sağlayıp (foreach) dizinin her elemanına teker teker =~ s fonksiyonu uygulamak gerekir
    Perl ile Mail göndermek

    Perl ile web üzerinden mail gönderme :

    Perl ile linux server'larda (genelde CGI/Perl destekleyen server'lar linux işletim sistemi kullanır) sendmail programı kullanılarak direk web üzerinden, herhangi ek program kullanmadan ziyarecti tarafından mail gönderilmesini ya da programın kendi kendinin bir şart oluştuğunda size ya da programın gidişatına bağlı olarak başka bir kimseye mail gönderilmesini sağlayabilirsiniz.

    Sendmail :

    Sendmail programı Linux server'larda web üzerinden mail gönderilebilmesine olanak veren bir programdır. Bu program aracılığıyla yazdığımız CGI programları ile web üzerinden mail gönderebilmemiz için sendmail'in linux server'ına göre tam yolunu bilmemiz gereklidir. Bu yol genellikle şu şekillerdedir :

    /usr/sbin/sendmail
    /usr/bin/sendmail

    Eğer server'daki sendmail yolunu bilmiyorsanız sunucu anasayfasında sunucu ile ilgili sıkca sorulan sorular bölümünde (FAQ) bulabilirsiniz ya da server adminlerine yazıp öğrenebilirsiniz. Windows altında sendmail programı bulunmadığı için az sonra yapacağımız yöntemle windows altında mail gönderemezsiniz.*


    Mail göndermek için önce mail programını open (MAIL, "|/usr/sbin/sendmail"); şeklinde mail programını açarsınız, daha sonra aynen mail gönderiyormuş gibi şu bölümlere gerekli yazıları ya da değişkenleri yazarsınız:

    print MAIL "From: kimden\@mail.com";

    Bu bölüme mailin kimden gönderildiğini yazmanız gerekiyor.

    print MAIL "To\:kime\@mail.com\n";

    Buraya mailin hangi adrese gitmesini istiyorsanız onu yazmalısınız.

    print MAIL "Subject\: Mesajın konusu\n\n";

    Bu bölüme de mailin "Subject/Konu" bölümünde yazmasını istediğiniz şeyi girmelisiniz.

    print MAIL "Bu mail web üzerinden otomatik olarak gönderilmiştir vs. vs. vs...\n\n";

    Bu bölüme mail içeriğini yazmalısınız.

    close (MAIL);

    Son olarak da mail programını aynen dosya işlemleri gibi kapatıyoruz.


    Dikkat etmemiz gereken en önemli nokta sendmail yolu. Eğer bu yol yanlış ya da eksik yazılırsa mail gitmez. Mail gönderirken değişkenleri kullanabilirsiniz ama eğer bir tekil değişkene e-mail atamanız gerekiyorsa "@" işaretinin önüne ters slash (\) koymanız gerekir. Aksi taktirde mail programı değişkeni yanlış algılar ve mail istenildiği şekilde gönderilemez.

    Buraya kadar anlamamış olabilirsiniz, bir örnek yaparsak ne kadar kolay olduğunu anlayacaksınız. Örneğimizde web sitemiz üzerinden bize mail gönderilmesini olanak sağlayan bir form-mail programı yapalım. Ziyaretci kendi mail adresini ve mesaj konusunu girsin, mesajını girsin ve formu göndersin, gönderilen bilgiler de bizim mail adresimize ulaştırılsın. Tabii bizim mail adresini de program içerisinde bir tekil değişken olarak tanımlamamız gerekiyor :


    #!/usr/bin/perl

    # mail.cgi

    print "Content-type:text/html\n\n";

    $adresim = "isminiz\@mailiniz.com";
    $sendmail = "/usr/sbin/sendmail";

    use CGI qw(:standard);

    $query = new CGI;

    $gonderen = $query -> param('gonderen');
    $konu = $query -> param('konu');
    $mesaj = $query -> param('mesaj');
    $istem = $query -> param('istem');

    if ($istem eq "gonder") {

    if ($gonderen eq "" or $konu eq "" or $mesaj eq "") {

    print "Mail adresiniz, mail konusu ya da mesaj bölümü boş bırakılmış.
    Bu bölümleri doldurmanız zorunludur. Lütfen geri dönüp tekrar deneyin...";

    exit;

    }


    open (MAIL, "|$sendmail");
    print MAIL "From\: $gonderen\n";
    print MAIL "To\:$adresim\n";
    print MAIL "Subject\: $konu\n\n";
    print MAIL "Siteniz iletişim sayfasından gönderildi:\n\n";
    print MAIL "$mesaj\n\n";
    print MAIL "\n";
    close (MAIL);

    print "Mesajınız başarıyla gönderildi, en kısa zamanda cevap verilecek. Teşekkür ederim...";

    exit;

    }

    print "<form action=mail.cgi method=post>";
    print "<input type=hidden name=istem value=gonder>";
    print "<b>Bize ulaşmak için aşağıdaki formu doldurun :</b><br><br>";
    print "<table width=500 cellpadding=0 cellspacing=0 border=0>";
    print "<tr>";
    print "<td width=50\%>";
    print "Mail adresiniz : ";
    print "</td>";
    print "<td width=50\%>";
    print "<input type=text name=gonderen>";
    print "</td>";
    print "</tr>";
    print "<tr>";
    print "<td>";
    print "Konu :";
    print "</td>";
    print "<td>";
    print "<input type=text name=konu>";
    print "</td>";
    print "</tr>";
    print "<tr>";
    print "<td>";
    print "Mesajınız :";
    print "</td>";
    print "<td>";
    print "<textarea name=mesaj></textarea>";
    print "</td>";
    print "</tr>";
    print "<tr>";
    print "<td>\ \;</td>";
    print "<td>";
    print "<input type=submit value=Gönder!>";
    print "</td>";
    print "</tr>";
    print "</table>";
    print "</form>";





    Programın içinde geçen "istem" değişkeni program akışını ayarlamak için atanmıştır. Eğer bu değişkenin içi boşsa en sondaki mail formu ekrana yazdırılır, yok eğer içeriği "gonder" ise yani form doldurulup gönderilmişse $gonderen, $konu ve $mesaj değişkenleri sorgulanır, içerikleri boşsa hata verilip program sonlandırılır (exit değilse mail gönderilir ve ekrana karşılama mesajı bastırılır. Bu programı kişisel server'ınızda denerseniz sadece karşılama sayfalarını ve programın içinde hata olup olmadığını görebilirsiniz ancak mail gönderemezsiniz.
    Dizin işlemleri okuma

    Perl ile Dizin İşlemleri :

    CGI sunucu tarafında çalışan bir programlama dilidir ve CGI programları sayesinde Perl dilinin kolaylıkları ve avantajlarını kullanarak kendi bilgisayarımızdaymışcasına rahat ve pratik olarak dosya ve dizin işlemleri yapabiliriz. Dosya işlemlerine örnek olarak dizindeki tüm dosyaları okuyup döngü ile ekrana yazdırma, klasör oluşturma, dosya silme (dosya içeriği değil!), klasör silme verilebilir.

    Klasör oluşturma :

    Klasör oluşturmak için mkdir() fonksiyonu kullanılır. mkdir() fonksiyonu ile içi boş bir dizin oluşturulur. Kullanımı şu şekildedir :

    mkdir ("bosdizin");

    Bu kod bize "bosdizin" isminde boş bir dizin oluşturacaktır.

    Örnek :


    #!/usr/bin/perl

    # dizin1.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    $query = new CGI;

    $dizinismi = $query -> param('dizinismi');
    $istem = $query -> param('istem');

    if ($istem eq "olustur") {

    if ($dizinismi eq "") {

    print "Lütfen geri dönüp dizin ismi bölümünü doldurun";
    exit;
    }

    mkdir("$dizinismi");

    print "$dizinismi isimli dizin başarıyla oluşturuldu.";
    exit;

    }

    print "<form action=dizin1.cgi method=get>";
    print "<input type=hidden name=istem value=olustur>";
    print "<b>Oluşturmak istediğiniz dizin ismi :</b> ";
    print "<input type=text name=dizinismi>";
    print "<input type=submit value=Oluştur!>";




    Dizin silme :

    Varolan boş bir dizini silmek için rmdir() fonksiyonu kullanılır. Kullanımı şu şekildedir :

    rmdir ("bosdizin");

    Bu kod bize mevcut "bosdizin" ismindeki boş dizini silme olanağı verir.

    Dosya silme :

    Dizin içerisinde herhangi uzantıda bir dosyayı unlink() fonksiyonunu kullanarak silebilirsiniz. Bu fonksiyonla silinen dosyalar kalıcı olarak silinirler yani geri dönüşüm klasörüne gönderilmezler. Tabii windows işletim sistemi için konuşuyorum. Kullanımı şu şekildedir :

    unlink ("dosya.txt");

    Bu kod "dosya.txt" dosyasının silinmesini sağlar. Daha önce belirttiğim gibi dosya uzantısı önemli değildir, dosya.txt yerine dosya.jpg de olabilirdi başka uzantılı bir dosya da...

    Dizin okuma :

    Perl ile bir dizinde mevcut tüm dosyaları değişkene atayıp ekrana yazdırabiliriz. Bunun için opendir() fonksiyonu kullanılır. opendir() fonksiyonunun 2 tane argümanı vardır; Dosya tutamacı, dosya yolu. Kullanımı şu şekildedir :

    opendir (DIR, "dizin");

    Bu kod ile "dizin" isimli klasörü açmış oluruz. Dizin açarken göreceli yol da kullanabiliriz. Mesela az önceki örnekte "dizin" yazan yere sadece bir nokta (.) yazarsak program içinde bulunduğu klasörü, iki nokta (..) yazarsak içinde bulunduğu klasörün bir üst klasörünü gösterir. Sözgelimi program cgi-bin/dizin içerisinde çalışıyorsa opendir (DIR, "."); şeklinde bir kullanım ile cgi-bin/dizin klasörü, opendir (DIR, ".."); şeklinde bir kullanımda cgi-bin dizini okunur.

    Dizin opendir () fonksiyonu ile açıldıktan sonra readdir(TUTAMAC) şeklinde içeriği isteğinize bağlı olarak kullanılabilir. Buradaki tutamaç opendir () fonksiyonu kullanılırken ilk argüman olarak kullanılan isimdir. Az önceki örnekte DIR yazısıdır. readdir () fonksiyonunu sort() fonksiyonu ile birlikte kullanırsak değişken içeriği alfabetik olarak sıralanır. Şu şekilde :

    opendir (DIR, ".");
    @dizi = sort(readdir(DIR));

    Bu kod önce içinde bulunduğu klasörü (.) açar, daha sonra alfabetik olarak sıralayıp @dizi isimli dizi değişkenin içeriğine atar. Dizin içeriği açılıp değişkene atandıktan sonra (ya da başka herhangi bir işlem yapıldıktan sonra) closedir(TUTAMAC) şeklinde dizin kapatılır.

    opendir (DIR, ".");
    @dizi = sort(readdir(DIR));
    closedir (DIR);

    Bu şekilde dizin içindeki her dosyayı dizi değişkenin birer elemanı halinde dizi değişkene atadıktan sonra bu dizi değişkeni kullanarak istediğimizi yapabiliriz. Örnek programda program içinde bulunduğu dizini açacak, dizi değişkene atayacak, kapatacak ve dizi değişkeni döngü ile ekrana yazdıracak :


    #!/usr/bin/perl

    # dizin2.cgi

    use CGI qw(:standard);

    print "Content-type:text/html\n\n";

    opendir (DIR, ".");
    @dizin = sort(readdir(DIR));
    closedir (DIR);

    print "<b> Dizin içindeki Dosyalar :</b>";

    print "<ul>";

    foreach $cevir (@dizin) {

    print "<li><a href=$cevir>$cevir</a><br>";

    }

    print "</ul>";






    KaSSaS bunu beğendi.

  3. #3
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb

    Perl Cookie

    Perl ile cookie'ler :

    Cookie'ler, web sayfalarında kullanılan programlar tarafından (CGI/Perl, PHP, ASP, JavaScript..) bazı işlemleri kolaylaştırmak, formları tekrar tekrar doldurma külfetinden kurtulmak ya da bir dahaki ziyarette hatırlamak üzere ziyaretcinin bilgisayarına gönderilen dosyalardır. Hemen hemen her server'da bulunan CGI.pm modülü ile cookie gönderme işlemi çok kolaylaştırılmıştır. Öncelikle CGI.pm modülünün kullanıldığını belirten kodu programın en başına yazmak gerekir

    use CGI qw(:standard);

    CGI.pm modülü kullanarak cookie göndermek için bir ilişkili dizi (hash) değişken oluşturulur;


    $cookie = cookie(-name => "cookie_ismi",
    -value => "cookie_degeri",
    -path => "cookie_yolu",
    -expires => "cookie_zamani");

    Örnekte "name" anahtarlı bölüm cookie ismidir. Daha sonra gönderilen cookie'yi okuturken bu isim ile çağırılır. "value" değeri cookie'nin içine yazdırılacak bilgidir. Bu bilgi form vasıtası ile gelen bir değişken olabileceği gibi, programın gönderebileceği bir değer de olabilir. Buradaki "path" değeri de programın tam yoludur. Bu bölüm isteğe bağlıdır yani -path ile başlayan satır olmasa da cookie gönderilir ve okunur. "expires" değeri de cookie'nin ne kadar süre geçerli olacağıdır. Bu bölüme gelebilecek değerler şu şekildedir:

    Oturumluk :

    -expires => "",

    "expires" değeri boş bırakılırsa bilgisayara bir oturumluk cookie gönderilir ve browser kapandığında bu cookie silinir.

    Günlük :

    -expires => "+1d",

    "expires" değeri yukarıdaki şekilde düzenlenirse bilgisayara "d" harfinden önce yazılan rakam kadar günlük cookie gönderilir. +5d yazıldığında 5 günlük, +15d yazıldığında 15 günlük cookie gönderilir.

    Aylık :

    -expires => "+1M",

    "expires" değeri yukarıdaki şekilde düzenlenirse bilgisayara "M" harfinden önce yazılan rakam değeri kadar aylık cookie gönderilir. +1M bir aylık, +5M beş aylık cookie gönderir.

    Yıllık :

    -expires => "+1y",

    "expires" değeri yukarıdaki şekilde düzenlenirse bilgisayara "y" harfinden önce yazılan rakam değeri kadar yıllık cookie gönderilir. Mesela +1y yazdığımızda bir yıllık, +10y yazdığımızda 10 yıllık cookie gönderilir.

    Cookie Silme :

    Eğer daha önceden gönderdiğimiz bir cookie'yi geçersiz hale getirmek istiyorsak aynı cookie ismi ile "expires" değerini "now" olarak girip bu cookie'yi aynen önceki cookie'yi yazdırıyormuş gibi yazdırırız.

    -expires => "now",

    Dizi değişken oluşturulduktan sonra CGI.pm modülü kullanılarak cookie makinaya gönderilir :

    print header(-cookie=>$cookie);

    CGI.pm modülü ile daha önce gönderilmiş cookie'yi okumak çok kolaydır :

    $isim = cookie("cookie_ismi");

    Burada yukardaki hash değişkenin "-name" anahtarına değer olarak verdiğimiz ismi yazdık ve $isim değişkenine atadık. Daha sonra bu değişkeni kullanarak makineye gönderdiğimiz isim değeri ile işlem yapabiliriz.

    Toparlamak açısından cookie gönderen bir örnek yapalım. Basit örneğimizde ziyaretci sayfaya geldiğinde ismini sorgulayan bir form olsun, ziyaretci ismini yazıp göndersin ve program makinaya cookie göndersin. Eğer ziyarecti daha önce bu formu doldurmuşsa cookie okunsun ve ekrana yazılsın, form gösterilmesin :


    #!/usr/bin/perl

    # cookie.cgi

    use CGI qw(:standard);

    $query = new CGI;

    $isim = $query -> param('isim');
    $istem = $query -> param('istem');

    $cookie_isim = cookie("ziyaretci_ismi");

    if ($istem eq "kukile") {
    $cookie = cookie(-name => "ziyaretci_ismi",
    -value => "$isim",
    -expires => "+1d");

    print header(-cookie=>$cookie);


    print "Cookie basariyla gonderildi, geri donus icin <a href=cookie.cgi>buraya tiklayin</a>";

    exit;
    }

    if ($istem eq "kukisil") {

    $cookie = cookie(-name => "ziyaretci_ismi",
    -value => "$isim",
    -expires => "now");


    print header(-cookie=>$cookie);

    print "Cookie basariyla silindi, geri donus icin <a href=cookie.cgi>buraya tiklayin</a>";

    exit;
    }

    print "Content-Type: text/html\n\n";

    if ($cookie_isim eq "") {

    print "<form action=cookie.cgi method=post>";
    print "<input type=hidden name=istem value=kukile>";
    print "Merhaba, lütfen isminizi girin : ";
    print "<input type=text name=isim>";
    print "<input type=submit value=\"Cookie'yi Gönder!\">";

    exit;
    }

    print "Hoşgeldin <b>$cookie_isim</b>, ismini içeren cookie 1 gün süreyle makinanda barınacaktır,";
    print "denemek için tarihini bir gün ileriye alıp tekrar ziyaret edebilirsin. ";
    print "Makinadaki cookie'yi silmek için <a href=cookie.cgi?istem=kukisil>buraya tıklayabilirsin";





    Cookie gönderilmeden önce :





    Cookie gönderildikten sonra :





    Dikkat !!! Cookie gönderirken cookie'den önce şu kodu :

    print "Content-Type: text/html\n\n";

    kullanmayın, cookie gönderildikten sonra kullanabilirsiniz. Eğer bu kodu cookie gönderilmeden önce (print header(-cookie=>$cookie); kodundan önce) kullanırsanız cookie'nin içerdiği bilgiler direk ekrana yazılır.
    Perl Modul kullanımı

    Perl'de modüller ve modül kullanımı :

    Modüller daha önceden başkası tarafından ya da bizim tarafımızdan yazılmış, programların kullanımını ve bir takım fonksiyonları daha kolay kullanılabilir hale getiren ya da yeni fonksiyonların kullanımını sağlayan perl paketleridir. Modüller genelde *.pm uzantılı olurlar. Genel olarak iki çeşit modül vardır :

    Perl'in içinde hazır olan modüller :

    Perl programı kurulduğunda içinde bir çok modül paketi hazır olarak gelir. Bu modülleri ve kullanımını windows altında Başlat/programlar/ActiveState Active Perl/Documantation yoluyla öğrenebilirsiniz.

    Programcı tarafından yazılan ek modüller :

    Bu tip modüller programcı tarafından hazırlanır ve program ile aynı dizine modul_ismi.pm şeklinde kaydedilir. Daha sonra modülün kullanılacağı programın üst satırına (shebang'dan sonra) şu şekilde modülün kullanılacağı belirtilir :

    use modul_ismi;

    Daha sonra mesela modül içinde sub isim {..} şeklinde bir alt program tanımladıysanız isim(..); şeklinde modüle atıf yapibilirsiniz.

    Birden fazla dosya kullanma (require komutu) :

    Bazen program yazarken kodlar o kadar fazla ve karışık olurlar ki kodları bölüp ayrı ayrı dosyalardan çağırmaya ihtiyaç duyabilirsiniz. Perl ile bunu yapabilirsiniz. Bunun için yapmanız gereken tek şey diğer dosyayı çağırmadan yani diğer dosyaya atıf yapmadan önce şöyle bir kod yazmanız :

    require "dosya.cgi";

    Çağıracağınız dosyanın uzantısı önemli değil. Ayrıca require ile çağırılan dosyanın en altında 1; satırı olmalıdır. Bu çağıran dosyaya "true" değeri yani çağırılan dosyanın okunabildiğini belirtir.

    Örnek :

    "require" ile çağırılan dosya (require2.cgi) :


    #!/usr/bin/perl

    # require2.cgi

    sub cagir {

    print "Bu satırlar require2.cgi içersinde bulunmaktadır.<br>";
    print "Perl ile başka bir dosyada bulunan alt programları çağırabilirsiniz<br>";
    print "Bu işlem dosya boyutunu ve içeriğini düşürerek işleri kolaylaştırır.";

    }

    1;



    require ile çağıran dosya :


    #!/usr/bin/perl

    # require1.cgi

    require "require2.cgi";

    print "Content-Type: text/html\n\n";

    print "İki çizgi arasındaki yazılar diğer dosyadan (require2.cgi) çağırılacak :<br>";
    print "<hr color=black>";

    &cagir;

    print "<hr color=black>";





    Require fonksiyonu ile başka dosyada bulunan bir alt programı &altprogram; şeklinde çağırabileceğiniz gibi, altprogram (); şeklinde de çağırabilirsiniz.
    Perl ile güvenlik

    Perl'de güvenlik :

    CGI programlarında en büyük güvenlik tehtidi SSI kodlarıdır. Eğer ziyaretcilerden form bilgileri varsa ve bu form bilgileri ekrana yazdırılıyorsa form bilgilerindeki SSI komutlarının form bilgilerinin açılması esnasında şu şekilde temizlemeniz gerekir :

    $deger =~s/<!--(.|\n)*-->//g;

    Eğer bir dosyanın içeriğinde ziyaretcilerin özellikle de kötü niyetli ziyaretcilerinin görmesi sakıncalı olabilecek bilgiler varsa;
    • Bu dosyayı cgi-bin dizininin içine koyun,
    • Mutlaka uzantısını ".cgi" ya da ".pl" yapın,
    • Eğer Apache web server kullanıyorsanız .htaccess kullanın,
    • Dosyanın bulunduğu dizinde mutlaka boş da olsa bir index.html bulundurun,
    • Eğer dosyadan sadece faydalanıyorsanız (require) dosyanın o dizinde bulunduğuna dair bir belirti, link, yazı vs. bulundurmayın,
    • Programı internet alanına gönderdikten sonra browser üzerinden programın klasörünün bulunduğu yolu ve dosyanın bulunduğu tam yolu yazıp dosyanın inip inmediğini ya da ekranda görüntülenip görüntülenmediğini defalarca kontrol edin.


    Bunun dışında eğer başkası tarafından hazır yazılmış bir program kullanıyorsanız programın dağıtıldığı web sitesini takip edin, buglardan ve bu bugların temizlenmesinden kötü niyetli kişilerden önce siz haberdar olun.

    .htaccess dosyalası ile dizin içeriğinin korunması :

    Eğer kullandığınız web server programı Apache ise dizin içerisindeki dosyaların görüntülenmemesi ve indirilememesi için şu şekilde bir dosyayı notepad vasıtası ile kaydedip dizin içine göndererek güvenliği sağlayabilirsiniz :



    AuthUserFile /dev/null
    AuthGroupFile /dev/null
    AuthName DenyViaWeb
    AuthType Basic


    <Limit GET>
    order allow,deny
    deny from all
    </Limit>



    Perl upload

    Yazılan programların web alanına gönderilmesi :

    Kendi yazdığınız ya da başkası tarafından yazılmış hazır programların internet'te sağlıklı olarak çalışabilmesi için FTP programı ile gönderilirken bir takım ayarların yapılması gereklidir.

    Dosyaları ASCII olarak gönderin :

    Yazdığınız CGI programlarını (*.cgi ya da *.pl) ve bu program içerisinde kullandığınız veritabanı dosyaları (*.txt, *.dat...) delenmemiş metin tabanlı yani ASCII dosyalardır. Bunun windows işletim sisteminde çalışan server'larda bir önemi olmasa da Linux işletim sistemi bulunan bir bilgisayarın server'ı için ASCII ve BINARY gönderilen dosyalar farklı şeyler ifade eder. Eğer bir cgi dosyası ASCII olarak değil de BINARY olarak gönderilirse internet alanında Internal Server Error (hata 500) hatası alınır.

    Cute FTP ile CGI dosyaları gönderilirken varsayılan ayarlarla çalışılıyorsa herhangi ek ayar yapmanıza gerek yoktur. Cute FTP dosyaları göndrirken ASCII - BINARY ayrımı yapar ve dosyanın türünü anlar, ona göre gönderir.

    Wise_FTP programını kullanıyorsanız CGI programlarını gönderirken sağdaki büyük pencerenin en altındaki radyo butonlardan "ASCII" butonunun işaretli olduğuna dikkat etmelisiniz. Aynı şekilde eğer resim, müzik ya da sıkıştırılmış ZIP dosyası gönderiyorsanız "Binary" seçeneğini işaretlemelisiniz.

    Diğer FTP programlarında da dosyaları gönderme esnasında ya da dosyaların gönderileceği server'a bağlanma esnasında yapılacak bir ayar mutlaka vardır.

    Chmod ayarı :

    Chmod Unıx sistemlerde dosyalara izin hakkı (permissions) vermeye yarayan bir komuttur. Unıx sistemlerde dosyalara 3 tür izin verilebilir.

    Bunlar;
    okuma (read), yazma (write), çalıştırma (execute) dir. chmod ayarı ile CGI dosyalarımızın ve içindeki şifre gibi bilgilerimizin güvenliğini sağlayabiliriz. CGI dosyaları genelde 755 chmod ile çalışırlar. Bunun anlamı; sahibi için okuma, yazma çalıştırma, diğerleri için ise okuma ve yazma anlamına gelir. Başka birisi serverınızdaki CGI dosyalarını silemez, içeriğini göremez ve değiştiremez. sadece çalıştırabilir. Veri dosyaları genelde CGI dosyalarının form vasıtasıyla gönderdiği bilgileri depolama amacıyla kullanılır. Genelde chmod'ları 644 ya da 666'dır. sadece yazılıp okunma izinleri vardır, çalıştırılamazlar.

    Cute FTP programı ile dosyayı gönderdikten sonra dosyaya chmod ayarı yapmak için dosyaya sağ tıklayıp "chmod" yazan bölümü tıklayın ve çıkan pencerede dosyaya vermek istediğiniz chmod'u yazın.

    Wise FTP ile chmod ayarı yapmak için dosyaya bir kere sol tıklayarak seçili hale getirin, sonra sağ tıklayın ve "chmod" yazan yere bir kere tıklayın, çıkan pencereye vermek istediğiniz değeri yazın.


    Eğer web alanına gönderdiğiniz bir CGI programını browser üzerinden çalıştırmak istediğinizde "Internal Server Error" hatası alıyorsanız şu ihtimalleri gözden geçirin ;

    • Perl yolu (shebang) yazılmışmı, doğru mu?
    • Dosya ASCII olarak gönderilmiş mi?
    • Chmod ayarı yapılmış mı, Doğru mu?
    • Dosyanın içinde bulunduğu dizinin CGI/Perl programları çalıştırma izni var mı?

    CGI/Perl programcılarının ya da hazır programları kullanan kişilerin dosyaları web alanına upload etmesi esnasında en çok yaptıkları hata bunlardır.

    Windows server'larda dosyaları direk klasörden klasöre taşıyabilirsiniz. ASCII - Binary olması farketmez zaten böyle de bir ayar yoktur. Ayrıca chmod ayarı yapmanıza da gerek yoktur.
    Lisans ve Copright

    Lisans ve Copyright :
    İnternet'de çeşitli sitelerde ücretli ya da ücretsiz olarak web sahiplerinin hizmetine sunulan programlar indirildiklerinde genelde bir lisans ile beraber gelirler. Dosyaların içinden çıkan lisans, programın hangi durumlarda, hangi şartlar altında ve ne tür sitelerde kullanılabileceği, hangi durumlarda ve hangi şartlar doğrultusunda kodlarda ve sayfa görünümünde oynama yapılabileceği, kim tarafından yapıldığı gibi bilgileri içerirler.

    Hukuki açıdan Lisans ve Copyright :

    Lisans programı yapan kişiyle kullanan kişi arasında imzalanmış bir anlaşma hükmündedir. Programı indirenler ve kullananlar lisansı okumuş ve kabul etmiş varsayılır. Lisans borçlar kanununda yer alan akit hükmündedir ve kullanıcı tarafını bağlayan bir sözleşmedir, kullanıcı lisansta yer alan hükümlerle bağlıdır. Program ancak lisansta yer alan hükümler doğrultusunda kullanılabilir, değiştirilebilir ya da fonksyinları değiştirilebilir ya da geliştirilebilir.

    Etik ve internet kültürü açısından lisans :

    Programları lisansa aykırı kullanmak kanunen olduğu kadar etik olarak da yanlış bir davranıştır, emeğe ve çalışmaya saygısızlıktır. Ortalama büyüklükte bir CGI/Perl programının yapımı normal şartlar altında 2-5 ay arasında değişmektedir. Bu programı yapan kişi onlarca belki de yüzlerce saatini bu programı yazabilmek için harcamış demektir. Ayrıca bir CGI/Perl programının ortaya çıkabilmesi ve paylaşıma açılabilmesi için bir çok kişi tarafından test edilmesi, daha sonra bu programı kullanacak kişilerin güvenliği için bu programın güvenliğini en üst noktaya çıkarılması gerekmektedir bu da internet'de harcanan zaman ve bağlantı masrafı demektir. Bu da ortada büyük bir emeğin -ve paranın- var olduğunu gösterir. CGI/Perl programları istenirse paylaşıma açılamayabilen programlardır. İnternette bulunan bir CGI/Perl programının kaynak kodlarını göremezsiniz, sadece ekran çıktılarını görebilirsiniz. Eğer bir kişi yazdığı CGI/Perl programını paylaşıma açtıysa, bu programı alıp kullanan kişilerin de bir sorumluluğu var demektir. Programı yazan kişinin emeğine, bilgisine ve çalışmasına saygı göstermek için programın içinde gelen lisansı dikkatlice okumak ve programı bu lisans çerçevesinde kullanmak gereklidir. Eğer lisanstaki şartlar sizi hoşnut etmezse, ters gelirse programcıyla bağlantı kurarsınız ya da programı kullanmazsınız. Unutmayın: hiç bir şey aylarca verilmiş bir emeğe saygısızlık için haklı neden değildir.

    Zaten CGI/Perl programcıları da programı kullanmanız için pek fazla birşey talep etmezler. En fazla programın altında, o programı görüp ihtiyacı olabilecek web sahiplerinin daha kolay ulaşabilmesi için bir link ya da bannerın bulunması isterler. Bu da bir çok gereksiz verilmiş linkin yanında yerine getirilmesi pek zor olmayan bir istek olsa gerek...

    Lisans ihlâli ve yaptırım :

    Öncelikle yukarıda bahsedildiği gibi programları lisanslarına aykırı kullanmak etiğe aykırıdır, emeğe saygısızlıktır.

    internet üzerinde çalışan programların (cgi, asp, php) lisansa aykırı kullanılması sonucu eğer ücretsiz bir server'da kullanılıyorsa program yapımcısının bir şikayeti üzerine server hesabı kapanabilir. CGI paralı forum programı UBB'nin programcıları lisansa aykırı kullanımları bu yolla engellemeye çalışmaktadırlar.

    Bilgisayar ve internet üzerinde yer alan programlar 5846 sayılı Fikir ve sanat eserlerine ilişkin kanun ve bunu değiştiren 4110 sayılı kanun ile koruma altındadırlar, programı lisansına aykırı kullananalar 5846 sayılı fikir ve sanat eserleri, bunu değiştiren 4110 sayılı kanun ve Türk Ceza kanununun bilişim alanındaki suçlar kitabı ile koruma altındadırlar, programları lisansına aykırı kullananlar, çoğaltanlar ve satanlar hakkında suç duyurusunda bulunulabilir, tahkikat yürütülebilir, dava açılabilir.

    Ayrıca bu tip bir lisans ihlâli sizi kötüniyetli duruma düşürecektir.

    Yukarıda bahsedilenler sadece CGI/Perl programları için değil, diğer server-side ve client-side programlar ve masaüstü yazılımları için de geçerlidir.


    Sizde ilerde program yazacağınızı, bu tip durumları yaşayacağınızı varsayarak kullandığınız programların lisansa uygun olduğundan emin olun, her zaman lisanslara dikkat edin ki ilerde kötü duruma düşmeyesiniz. Ayrıca eğer bir program yazdıysanız ve paylaşıma açacaksanız mutlaka isteğiniz doğrultusunda, ayrıntılı ve açık bir lisans hazırlayın ve kullanıcıları lisansa uygun olarak kullanmaları için uyarın...

    -bitti-
    Acemliler.net ten alınmıştır

    KaSSaS bunu beğendi.

  4. #4
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb Başka Bir Anlatımla PERL!?

    Perl
    Önsöz
    GİRİŞ
    SABİT VE DEĞİŞKENLER
    OPERATÖRLER
    Koşul ve Kontrol Deyimleri
    DÖNGÜLER
    LİSTE ve DİZİLER
    BİLEŞİK DİZİLER
    DOSYA İŞLEMLERİ
    FORMATLI YAZDIRMA
    STANDART GİRİŞ ÇIKIŞ YÖNLENDİRMESİ
    KOMUT SATIRI SEÇENEKLERİ
    Pattern (string / kelime ) Örneği BulmaPattern Matching)

    REFERANSLAR

    Önsöz

    Kitap Hakkında
    Kitap Perl'in en önemli konularını işliyor. Çok fazla sayıda örnek ve program bulunmaktadır.
    GİRİŞ

    Perl Komutları Nasıl Yazılır?
    Beğendiğiniz bir editörle yazabilirsiniz. İlk satırda perl'un icra edilebilir dosyasının sistemdeki tam yolu verilir. Satırın başına( #! ) özel karakterleri mutlaka yazılmalıdır.
    #!/usr/bin/perl gibi...

    Kodlama bittikten sonra editörden çıkılır ve Unix ve benzeri sistemlerde o dosyaya icra hakkı vermeniz gerekir. Varsayalım ki program adı deneme.pl olsun
    chmod +x deneme.pl

    komutu bu işlemi yerine getirir.
    Program Nasıl Çalışır?
    Komut satırından program adını girip Enter tuşuna basınız.
    Örnek program :
    test.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $girilensatir = <STDIN>;

    print($girilensatir);
    Bu programın ilk satırında programın icrası için gereken dosyanın yeri belirtilmiştir. İkinci satırda klavyeden girilen değer $girilensatir değişkenine aktarılır. (Burada klavyeden merhaba yazalım). Üçüncü satırda ise bu değer ekrana yazdırılır.
    Ekrandaki görüntü şu şekildedir:
    > deneme.pl


    > merhaba


    > merhaba

    Açıklama satırları nasıl belirtilir. Açıklama yapmak amacıyla kullanacağımız satırların başına # işareti koyarız.
    # bu bir açıklama satırıdır
    # perl tarafından dikkate alınmaz

    Bu durumda önceki programımızı şu şekilde kodlayalım
    test_comment.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    #Bu program klavyeden girileni

    #ekrana yazar.

    $girilensatir = <STDIN>;

    print($girilensatir);
    Programın çalışması bir önceki ile tamamen aynıdır. # ile başlayan satırlar sadece bizi aydınlatmak, not tutmak içindir. Perl bu satırları değerlendirmeden geçer.
    Şimdi şu satırı ele alalım;
    $girilensatir = <STDIN>;

    Bu satir bir perl ifadesidir(statement) her bir parçasına($girilensatir,=,<STDIN>, ise gösterge (token) denir. $girilensatir bir skalar değişkeni belirtir. $ isareti değişkenin skalar olduğunu girilensatir ise değişkenin adını belirler. = göstergesi kendisinin (bize göre) sağındaki ifadeyi solundakine ata anlamı taşır. <STDIN> standart giriş elemanını yani klavyeden girişi ifade eder. Son olarak ; göstergesi ise ifadenin bitişini gösterir ve ifade sonlarında mutlaka bulunmalıdır aksi takdirde hata mesajı alırsınız.
    Yukarıdaki açıklamalar tüm perl benzer ifadelerinde geçerlidir. Yazım sırasında istisnai durumlar dışında karakter aralarında boşluk, tab v.b whitespaces karakterleri kullanılabilir.Aralardaki boşluk sayısı önemli değildir.
    Gelelim yazdırmaya;
    Standart çıktı(ekran)ya yazdırma görevini print yapar. print($girilensatir); ifadesiyle $girilensatir skalar değiskeninin içeriği ekrana yazdırılır. Aslında print fonksiyon olarak çalışır. $girilensatir 'ı ise arguman olarak kullanır. Arguman 1 den fazlada olabilir. Print ($girilensatir, $girilensatir); ifadesinde 2 arguman kullanılmıştır. Her ikisi de klavye girişini alan $girilensatir değişkenidir. Bu durumda busatırın çalışması anında $girilensatir değeri, ekrana 2 defa yazdırılır.
    Dosya Listesi
    · test.pl
    · test_comment.pl
    SABİT VE DEĞİŞKENLER

    1.Sabitler

    A)Sayısal Sabitler:

    Sayısal sabitler,programın çalışması esnasında gereken sayısal sabit değerlerdir. Perl 8 ve 16 tabanlı sayısal değerlerin kullanımını da sağlar
    1245100.45.0000340430x23 ...gibi
    B)String Sabitler:

    String sabitler,programın çalışması esnasında gereken alfasayısal sabit değerlerdir. Alfabetik ve Alfabetik/sayısal/özelkarakter karışımı olabilirler. Tırnak içindeki ifadelerdir. Perl stringlerde; Tek, çift, geri tırnak kullanır. Bunlar birlikte de kullanılabilirler. Kurallarını göreceğiz.
    'Ertan Türkmen'"Ertan Türkmen""Dedi ki, \"O Ankara'dan geldi.\""'Ahmet Trabzon\'ludur' ...gibi
    stringlerde EscapeSequence denilen özel işlevli karakterlerde kullanılır.
    Escape SequeNCe karakterlerinden bazıları ve anlamları:
    \a
    Alarm
    \b
    Backspace -geri-
    \e
    Escape -çıkış-
    \f
    Form Feed -form besleme -
    \n
    Newline -yeni satır-
    \r
    Carriage return -satır sonu-
    \t
    Tab - x karakter atla -
    \v
    Vertical Tab - dikey atla -

    ilerleyen derslerde konuyla ilgili örnekler görecek ve daha iyi anlayacağız.
    2.Değişkenler

    a)Skalar değişkenler : İçersinde değişebilen değerler bulunduran birimlerdir. İlk karakteri $ işaretidir.Bu karakterden sonra en az 1 alfabetik karakter bulunmalıdır. Değişken adında kural olarak bu karakterlerden hemen sonra alfabetik, sayısal karakterler ve _ karakteri kullanılabilir. Değişken uzunluğu serbesttir.
    $ad, $ad_soyad, $a1
    gibi değişken adlari geçerli olup aşağıdakiler geçersizdir.
    ad
    # $ karakteri olmadığından
    $
    # $ dan sonra en az 1 alfabetik karakter gerektiğinden
    $47x
    2.karakter sayısal olamaz
    $_ad
    # 2.karakter alfabetik olmalı
    $ad!
    # ! karakteri kullanılamaz

    Küçük ve büyük harf kullanımı önemlidir ve farklı değişkenleri temsil ederler. Bu demektir ki; $AD ile $Ad ve $ad farklı değişkenlerdir.

    Değişkenlere değer atama:

    Eşitliğin bize göre sağındaki değer (sayısal/alfabetik/karışık olabilir) solundaki değişkenin içine konur. Aşağıdaki ifadeyi inceleyiniz.
    $ADI_SOYADI = "Ertan TURKMEN";
    $ADI_SOYADI değişkeni içindeki değer "Ertan TURKMEN" dir.
    benzer şekilde,
    $MAAS = 125000;
    $MAAS değişkeni içeriği 125000 dir
    Değişkenin içinde önceden bir değer varsa,önceki değer silinir, son atanan değer geçerli olur.

    Aritmetik Operatörler:

    Perl de kullanılan TEMEL aritmetik operatörler;
    Toplama
    +
    Çıkartma
    -
    Çarpma
    *
    Bölme
    /

    Örnek program : Verilen değerin Km ve Mil cinsinden çevirimini yapar.
    milkm.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Mesafeyi giriniz: \n"); $mesafe = <STDIN>; chop ($mesafe); # chop fonksiyonu giriş sonundaki karakteri atar# programımızda son karakter Enter tuşuna bastığımız için# yeni satır (\n) karakteri# olduğundan onu atar(siler). $mil = $mesafe * 0.6214; $km = $mesafe * 1.609; print ($mesafe, " km = ", $mil, " mil\n"); print ($mesafe, " mil = ", $km, " km\n");Program satırlarında kullanılan "\n" göstergesi alt satıra geçişi sağlayan yeni satır karakteridir.

    Çalışması:
    milkm>Mesafeyi giriniz:>10>10 km = 6.2139999999999995 mil>10 mil = 16.09 km
    a.1)Tamsayi (integer) Skalar değişkenler:

    İçerisinde tamsayı sabit ve literal bulundurabilirler. integerlar kayar noktalı (floating-point--birazdan inceleyeceğiz--)değerler gibi işlem görürler.
    Örnek program: adı prg.pl olsun...
    prg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $deger = 1234567890; print ("1.değer: ", $deger, "\n"); $deger = 1234567890123456; print ("2.değer: ", $deger, "\n"); $deger = 12345678901234567890; print ("3.değer: ", $deger, "\n");Çalışması :
    >prg>1.değer: 1234567890>2.değer: 1234567890123456>3.değer: 12345678901234567168
    çıktısı verir. Görüldüğü gibi ilk 2 değerde sorun yoktur.3.değer yanlış sonuç üretir. Çünkü tamsayı için fazla değer içermektedir.
    a.1)Kayar Noktalı (floating-point) Skalar değişkenler:

    En fazla 16 rakam kabul edebilirler. Bu değişkenler tamsayı, ondalıklı, exponent(e üzeri) ve -/+ işaretli değerleri saklayabilirler. Örneğin, aşağıdaki değerlerle işlem yapabilirler.
    11.4 , -275 , -0.3 , .3 , 3. , 5.47e+03 , ...v.b.
    Örnek program : Adı prgsk1.pl olsun,
    prgsk1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $deger = 34.0; print ("1. deger ", $deger, "\n"); $deger = 114.6e-01; print ("2. deger ", $deger, "\n"); $deger = 178.263e+19; print ("3. deger ", $deger, "\n"); $deger = 123456789000000000000000000000; print ("4. deger ", $deger, "\n"); $deger = 1.23e+999; print ("5. deger ", $deger, "\n"); $deger = 1.23e-999; print ("6. deger ", $deger, "\n");Programın Çalışması :
    > prgsk1.pl> 1. deger 34> 2. deger 11.460000000000001> 3. deger 1.7826300000000001e+21> 4. deger 1.2345678899999999e+29> 5. deger Infinity> 6. deger 0
    b)String değişkenler:

    String (karakter/karakterler içeren dizi) içerirler. Bu değerler alfabetik ve sayısal sabit veya değişken olabilirler.
    $AD_SOYAD = "Ertan TURKMEN";
    komutuyla "Ertan TURKMEN" stringi $AD_SOYAD string değişkenine atanır.
    $number = 11;$text = "Bu text sayı içerir.İçerdiği sayı $number.";
    komutlarının icrası sonucu $number'a 11 sayısı atanır. $text değişkenine ise "Bu text sayı içerir. İçerdiği sayı $number." Stringi atanır. Sonuçta $text'in içeriği şudur.
    "Bu text sayı içerir.İçerdiği sayı 11."
    Stringlerde de Escape Sequence karakterler kullanılır.
    Bunlar aşağıdadır:
    \a
    Zil sesi
    \b
    Backspace
    \cn
    Ctrl+n karakteri
    \e
    Escape
    \E
    L, \U or \Q etkisini sonlandır
    \f
    Form Feed -
    \I
    Sonraki harfi küçüğe çevirir
    \L
    Sonraki tüm harfleri küçüğe çevirir
    \n
    Newline -yeni satır-
    \r
    Carriage return
    \Q
    Özel örnek karakterleri arama
    \t
    Tab
    \u
    Sonraki harfi büyüğe çevir
    \U
    Sonraki tüm harfleri büyüğe çevir
    \v
    Vertical Tab - dikey atla -

    Tek ve Çift tırnaklı string farkı:
    Bunu örnekle inceleyelim.
    $string = "Bir stringdir";$text = "Bu $string";# $text'in içeriği "Bu Bir stringdir"
    Örnek 2:
    $text = 'Bu bir $string'; #$text'in içeriği 'Bu bir $string'
    İki örnek arasında fark açıkça görülmektedir. Tek tırnak içindeki string aynen saklanır. Değişken ve hatta \n gibi karakterlerde kendi özelliklerini icra eder şekilde kullanılamaz. (sadece \ ve ' karakterleri hariç). Örnek 3:
    $text = 'Bu string.\n';$text içeriği: Bu string .\n şeklindedir.
    Örnek 4:
    $text = 'Burada \', tek tırnak karakteri var';$text içeriği: Burada ', tek tırnak karakteri var
    Örnek 5:
    $text = 'Stringin son karakteri backslash \\';$text içeriği: Stringin son karakteri backslash \ şeklindedir.
    String ve Sayısal değerlerde değiştirilebilirlik:
    Örnekle inceleyelim.
    $string = "43";$Sayı = 28;$result = $string + $Sayı;$result içeriği 71 dir.
    Bir de şu örneği inceleyelim:
    number = <STDIN> #klavyeden giriş bekler 22 girdik diyelim # $number içeriği 22\n dir (\n enter tusu)chop ($number); # $number içeriği su anda 22$result = $number + 1; #$result içeriği 23
    Şöyle bir atama sonucunda ise :
    $result = "hello" * 5; $result içeriği 0 dır.
    çünkü hello sayısal olmadığı için sayısal değeri 0 dır
    Eğer string ifadede sayısal ve alfabetik değer varsa, $result = "12o34"; gibi.. Bu durumda ortadaki o harfi öncesi geçerlidir. $result içeriği 12'dir.
    ALTERNATİF STRİNG AYRAÇLARI

    Aşağıdaki örneğe bakalım;
    $say = 5; print ("$say\n"); # 5 basar print ('$say\n'); # $var\n basar
    örnekte ' ve " ayraçlarını görüyoruz. Perl başka ayraç elemanları da sunar. Bu işlev için, q kullanıp sonraki ayraç elemanını belirleyebiliriz.
    q!merhaba $kim! gibi...
    bu ifade ile aşağıdaki ifade aynıdır.
    'merhaba $kim'
    String sınırlayıcı olarak qq kullanırız.
    qq/This string contains $var./
    Burada / karakteri stringi ayırır(sınırlar).
    Stringi kelimelere ayırma-kesme- işlevini qw ile yaparız. Aşağıdaki iki satır aynıdır.
    @kelimeler = qw/Bu bir cümledir/; @kelimeler = split(' ', q/Bu bir cümledir/);
    her iki durumda da @kelimeler ' e şu liste atanır;
    ("Bu ", " bir ", " cümledir")
    << KULLANARAK STRİNG TANIMLAMA
    << işareti ile string başı tanımlanır. Bu string boş satır görene kadar devam eder.
    $A = << here is the string bu ikinci satır } $A içeriği yandaki ilk iki satırdır. üçüncü satır dördüncü satır
    << sonra konacak string, string sonunu belirler.
    str = <<END (veya şu şekilde <<'END' ) bu birinci satır bu ikinci satır END (string sonu)
    Şu da doğrudur.
    $end = "END"; $str = <<"$end" bu ilk satır bu ikinci satır END
    Şu kullanıma bakın;
    print <<END Merhaba! Iyi calışmalar! END
    çıktısı
    Merhaba! Iyi calışmalar! print <<END x 2 Merhaba! END
    çıktısı
    Merhaba! Merhaba! $satır = <<END1 <<END2 birinci kısım END1 ikinci kısım END2
    $satır içeriği
    Birinci kısım İkinci kısımNot: \n dahildir.
    << aralarında boşluk olmamalıdır.

    Dosya Listesi

    · milkm.pl
    · prg.pl
    · prgsk1.pl
    OPERATÖRLER

    Aritmetik Operatörler:

    Daha evvel temel operatörleri görmüştük. (Toplama:+, Çıkarma:-, Çarpma:*, Bölme:/) Şimdi ise üs alma ,mod (artık) ve unary operatörlerini görelim.
    Üs alma için ** ,mod için % ,unary negation için - operatörü kullanılır.
    Örnek:
    $x = 2 ** 4 # 2x2x2x2 anlamındadır ..sonuçta $x içeriği 16 dır.$y = 2 ** 2 # $y içine 4 atanır.$x = 2 ** $y; # $x içine 2**4 yani 16 atanır.
    Örnek program : Program Adı usprg.pl olsun
    usprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl #program 2 rakamının girdiginiz deger olarak üssünü bulur print ("Kullanacaginiz üs degerini giriniz:\n"); $us = <STDIN>; chop ($us); print ("2 nin $us .üssü = ", 2 ** $us, "\n");Çalışması :
    >usprg.pl>Kullanacaginiz üs degerini giriniz:>16>2 nin 16 .üssü = ", 65536> Negatif ve noktalı sayı kullanmak hataya sebep olur
    -5) ** 2.5 ..gibi
    Yine sınırları aşan sayılar da hataya neden olur
    10 ** 999999 ..gibi
    MOD (Artık) Operatörü:

    $x = 25 % 4;
    Bu örnekte 25,4'e bölünür kalan(artık) 1’dir. Dolayısıyla $x 'in değeri 1’dir. İnteger olmayanlar integer'a(Tamsayı) dönüştürülür
    $x = 24.77 % 4.21;
    Bu örnekte 24, 4'e bölünür kalan olmadığından $x değeri 0 dır.
    MOD işlemlerinde % işaretinin sağında 0 olamaz çünkü sıfıra bölme imkansızdır. Bu tür işlemler hata mesajı verir.
    $x = 25 % 0; $x = 25 % 0.1;
    Unary negation operatörü:

    - operatörü
    Değeri -1 ile çarpmaktır.
    - işareti bu operatör ile kullanımında eksi işareti anlamında değildir.
    - 5; # tamsayı -5' e esittir- $y; # $y * -1 anlamındadır.
    Ayrıca -operant (azaltma),+operant (arttırma), kullanım öncesi arttırma ++operand, kullanım öncesi eksiltme –operand kullanım sonrası arttırma operand++, kullanım sonrası elsiltme operand--, operatörleri de kullanılır.
    # Normal yol: $Sayfano = 5;$Sayfano = $Sayfano + 1;print($Sayfano, "\n");
    program çıktısı : 6
    #Önceden arttırmalı yol:
    $Sayfano = 5;print(++$Sayfano, "\n");
    program çıktısı : 6
    Önceden eksiltmeli opr kullanımı.
    $sayi = 5;$toplam = --$sayi + 5;print("$sayi $toplam \n");
    Çıktı : 4 9
    sonradan arttırmalı opr kullanımı.
    $sayi = 5;$toplam = $sayi++;print("$sayi $toplam \n");
    Çıktı : 6 5
    KIYAS OPERATÖRLERİ KULLANIMI:

    $x = $a == $b;
    Yukarıdaki satırda $x in değeri, $a ve $b daki değerlerin durumuna bağlıdır.
    Şöyleki: eğer $a,$b ye eşitse, $a == $b eşitliği sonucu doğru değerini taşır(true) ve $x in değeri 0 OLMAZ. Sıfır olmayan değer taşır.eğer $a,$b ye eşit değilse, $a == $b eşitliği sonucu yanlış değerini taşır(false) ve $x in değeri 0 dır(Sıfır). Burada == operatörünün bir kıyas işlemi yaptığını görüyoruz. Kontrol ifadelerinde kıyas operatörleri sık sık kullanılır. örneğin;
    if ($a == $b) { print("$a eşittir $b\n");}
    Perlde, kıyas operatörleri 2 sınıfta kullanılır.
    1. Sayısal işlemlerde
    2. String işlemlerde
    Tamsayı Kıyas Operatörleri:

    Operatör
    Açıklama
    <
    Küçük
    >
    Büyük
    ==
    Eşit
    <=
    Küçük veya eşit
    >=
    Büyük veya eşit
    !=
    Eşit değil
    <=>
    Kıyaslama dönüşü 1, 0, veya-1

    $a değişkeninde 5 varsa
    $a > 4 sonucu true (doğru) veya 0 olmayan değer$a > 7 sonucu false (yanlış) veya 0 dır.
    <=> operatörü özel bir durum arz eder. Aşağıdaki 3 değerden birini döndürür.
    0, Kıyaslanan iki değer eşitse 1, ilk değer büyükse -1, ikinci değer büyükse
    String Operatörler

    String operatör
    Kıyas işlemi
    Sayısal opr.karşılığı
    lt
    Küçük
    <
    gt;
    Büyük
    >
    eq
    Eşit
    ==
    le
    Küçük veya eşit
    <=
    ge
    Büyük veya eşit
    >=
    ne
    Eşit değil
    !=
    cmp
    Kıyaslama dönüşü 1, 0, veya-1
    <=>

    Örnekler :
    $result = "aaa" lt "bbb"; # Doğru$result = "aaa" gt "bbb"; # Yanlış$result = "aaa" eq "bbb"; # Yanlış$result = "aaa" le "aaa"; # Doğru$result = "aaa" ge "bbb"; # Yanlış$result = "aaa" ne "aaa"; # Yanlış$result = "aaa" cmp "bbb"; # -1
    String - Sayısal Kıyas Karşılaştırması:

    Aşağıdaki örneklere bakalım.
    $sonuç = "123" < "45"; # 123 ile 45 sayısal değer olarak kıyaslanır..sonuç yanlış(false)$sonuç = "123" lt "45"; # 123 ile 45 alfabetik değer olarak kıyaslanır sonuç doğru(true).
    Floating-Point Sayılarda Kıyaslama:

    Bu sayılarda dikkat edilecek şey ondalık sonrasının net olmasıdır. Yuvarlanan sayı olursa sonuç hatalı çıkar. Ne demek istediğim aşağıdaki örnekten anlaşılacaktır.
    floating_point.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $sayi1 = 14.3; $sayi2 = 100 + 14.3 - 100; print("sayi 1 : $sayi1, sayi 2 : $sayi2\n"); if ($sayi1 == $sayi2) { print("sayi 1,sayi 2 ye eşittir\n"); }else { print("sayi 1,sayi 2 ye eşit degildir\n"); }Çıktı:
    sayi 1 : 14.300000000000001, sayi 2 : 14.299999999999997
    sayı 1, sayı 2 ye eşit değildir
    Mantıksal operatörler ve alt ifadeler :

    Örnek:
    $myval = $a || $b || $c;
    aşağıdaki ifadeyle aynıdır
    if ($a != 0) { $deger = $a;} elsif ($b != 0) { $deger = $b;} else { $deger = $c;}
    Örnek :
    $deger = $a && $b && $c;ifadesi aşağıdakiyle aynıdır.if ($a == 0) {$deger = $a;} elsif ($b == 0) {$deger = $b;} else {$deger = $c;}
    ATAMA OPERATÖRLERİ

    Temel atama operatörü = göstergesidir. $a = 5; # 5 değeri $a değişkenin içine yerleştirilir.

    ATAMA operatörleri tablosu

    Operatör
    İzah
    var = op1;
    op1,var 'a atanır(op1 değeri var içine yerleşir).
    var += op1;
    var + op1 ,var'a atanır.
    var -= op1;
    var - op1 ,var'a atanır.
    var *= op1;
    var * op1 ,var'a atanır.
    var /= op1;
    var / op1 ,var'a atanır.
    var %= op1;
    var % op1 ,var'a atanır.
    var .= op1;
    var. op1 ,var'a atanır.
    var **= op1;
    var ** op1 ,var'a atanır.
    var x= op1;
    var x op1 ,var'a atanır.
    var <<= op1;
    var << op1 ,var'a atanır.
    var >>= op1;
    var >> op1 ,var'a atanır.
    var &= op1;
    var & op1 ,var'a atanır.
    var |= op1;
    var | op1 ,var'a atanır.
    var ||= op1;
    var || op1 ,var'a atanır.
    var ^= op1;
    var ^ op1 ,var'a atanır.

    Örnekler :
    $result = 42; # $result 'un değeri 42 olur$value1 = $value2 = "a string"; # Hem $value1,hem de $value2 nin #içine "a string" atanır.$var = $var + 1; ile $var += 1;
    aynı işlemi ifade eder. ($var değişkeninin değeri 1 arttırılır ve yeni değer tekrar $var'a konur)

    Atama işlemleri örnekleri içeren bir tablo

    İfade kullanımı
    Yürütülen işlem
    $a = 1;
    1,$a içine yerleşir
    $a -= 1;
    $a = $a - 1;
    $a *= 2;
    $a = $a * 2;
    $a /= 2;
    $a = $a / 2;
    $a %= 2;
    $a = $a % 2;
    $a **= 2;
    $a = $a ** 2;
    $a &= 2;
    $a = $a & 2;
    $a |= 2;
    $a = $a | 2;
    $a ^= 2;
    $a = $a ^ 2;

    Alt ifadelerle Kullanım :

    ($a = $b) += 3;
    bu örnekte işleyiş şöyledir. Önce parantez içi işlenir. Bu durumda $a = $b; ve $a += 3; işlemleri yapılır
    Otomatik Arttırma ve eksiltme:

    $a = $a + 1; $a += 1;
    Her iki örnekte de $a değeri 1 artırılmaktadır. $a değerini otomatik arttırma kullanımı ise şöyledir
    $a++; veya ++$a;
    }print("Son !\n");Çalışması :
    >prepprg2.pl Deger: 1 Deger: 2 Deger: 3 Deger: 4 Deger: 5 Deger: 6 Son ! >
    Bu örneğin çalışmasını anlamak için şu tabloyu inceleyelim.
    $valueTest anında
    Sonuç
    $value Testten sonra
    0
    true (0 <= 5)
    1
    1
    true (1 <= 5)
    2
    2
    true (2 <= 5)
    3
    3
    true (3 <= 5)
    4
    4
    true (4 <= 5)
    5
    5
    true (5 <= 5)
    6
    6
    false (6 <= 5)
    7 (while döngüsü çıkışı)

    STRiNGLERDE OTOMATİK ARTTIRMA

    $string1 = "abc";$string1++;
    Şu anda $string1 içindeki değer "abd" dir.
    Stringlerde otomatik eksiltme olmaz ($string1--). Böyle bir durumda string içindeki değer -1 olur.
    $string1 = "aBC";$string1++;
    Şu anda $string1 içindeki değer "aBD" dir.
    $string1 = "abz";$string1++; # $string1 içi "aca" dır.$string1 = "AGZZZ";$string1++; # $string1 içi "AHAAA" dır.$string1 = "bc999";$string1++; # $string1 içi "bd000" dır
    STRİNG BİRLEŞTİRME VE TEKRARLAMA:

    · . operatorü, string birleştirir .
    · x operatorü, string tekrarlar.
    · .= operatorü, string birleştirir ve atama yapar.
    Birleştirme :
    $yenistring = "tas" . "kafa";
    satırı sonucu olarak $newstring değişkeninin içeriği "taskafa" olur.
    . operatörü değişkenlerle de kullanılır. Örn:
    $string1 = "tas";$string2 = "kafa";$yenistring = $string1 . $string2;
    $yenistring değişkeninin içeriği " taskafa " olur.
    Tekrarlama:
    $yenistring = "t" x 5;
    $yenistring değişkeninin içeriği "ttttt" olur.
    x operatörü değişkenlerle de kullanılır. Ör:
    $string1 = "t";$tekrar = 5;$yenistring = $string1 x $tekrar;
    $yenistring değişkeninin içeriği "ttttt" olur.
    x operatörü kullanırken x etrafında boşluk bulunmalıdır.
    $yeni = $eski x 5; #Doğru kullanım$yeni = $eskix 5; # Yanlış "$yeni = $eski x5; # Yanlış "
    BİRLEŞTİRME ve ATAMA:

    $a = "Ata";$a .= "türk"; # $a nın değeri şimdi "Atatürk" dir.
    Aşağıdaki kullanımda aynı sonucu verir.
    $a = "Ata";$a = $a . "türk";
    Örnek Program : Program adı strcon.pl olsun
    strcon.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl$sonuc = "";print("Kelimeler giriniz çıkış için sadece enter basınız\n");$gir = <STDIN>;chop ($gir);while($gir ne ""){$sonuc .= $gir;$gir = <STDIN>;chop ($gir);}print ("Girilen kelimeler:\n");print ("$sonuc \n");Çalısması:
    >strcon.plKelimeler giriniz çıkış için sadece enter basınızbensenoGirilen kelimeler: benseno>
    DİĞER OPERATÖRLER:

    , (virgül) operatörü; ifadeyi parçalara ayırır. Ör:
    $a1 += 1;$a2 = $a1;
    satırları virgül kullanımı ile şu şekilde kodlanır,
    $a1 += 1, $a2 = $a1;
    , operatörü atama işlemlerinde sıkça kullanılır, Ör:
    $val = 26;$result = (++$val, $val + 5);
    ilkönce ++$val işlenir çünki virgülden öncedir $val,27 olur. Sonra 5 eklenir 32 olur bu değer,$result 'e atanır.
    ŞART(Koşul) operatörleri:

    Bunlar ? ve : operatörleridir. Ör:
    $sonuc = $a == 0 ? 14 : 7;
    çalışmasını inceleyerek anlayalım;eğer $a == 0 ise , $sonuc değişkenine 14 atanır, değilse 7 atanır.Yani koşul doğru ise ? sonrası, yanlış ise : sonrası atanır.,eğer bu işlemi if else ile yapmak isteseydik şöyle kodlayacaktık.
    if ($a == 0) { $sonuc = 14;} else { $sonuc = 7;}
    Bir de şunu inceleyelim;
    $kosul == 43 ? $a1 : $a2 = 14;
    Buradaki işleyiş ise şöyledir; Eğer $kosul içindeki değer 43 ise, $a1 'e 14 atanır. Değilse $a2'ye 14 atanır..
    Örnek Program : program adı pwdprg.pl olsun
    pwdprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perlprint ("Parola giriniz:\n");$parola = "ertan";$giris = <STDIN>;chop ($giris);$sonuc = $giris eq $parola ? "Dogru parola!\n" : "Yanlis parola.\n";print ($sonuc);Çalışması:
    >pwdprg.plParola giriniz:abcYanlis parola.>
    Dosya Listesi

    · usprg.pl
    · floating_point.pl
    · preprg.pl
    · preprg2.pl
    · strcon.pl
    · pwdprg.pl

    Koşul ve Kontrol Deyimleri -- Dallanma ve Yönlendirme

    1. if Deyimi :
    if ($sayı) {

    print ("Sayı sıfır değil..\n");
    }

    Yukarda bir if deyimli perl program parçası görüyorsunuz. if deyimi yanında () parentez içersindeki değer veya değişken sınanır.Parantezler arası bu kısım şart ifadesidir (Örneğimizde ($sayı). Bu ifadenin içerdiği sonuç doğru ise oklu parentezler (Blokbaşı ve sonunu ifade eder ki kullanılması şarttır) içerisindeki kısım blok olarak icra edilir. Sonuç yanlış ise Blok dışına geçilir. Sonucun doğru(true)olması demek parentez içi değerin 0 olmaması demektir. Değer 0 ise sonuçyanlıştır (false).
    Örnek Program : Program adı ifprg.pl olsun
    ifprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("Bir sayı giriniz:\n");

    $sayi = <STDIN>;#Program calıştığında burada 7 girelim

    chop ($sayi);

    if($sayi){

    print ("Girilen sayı sıfır değil.\n");

    }

    print ("Program sonu...\n");
    Çalışması:
    >ifprg

    >Bir sayı giriniz:

    >7

    >Girilen sayı sıfır değil.

    >Program sonu...

    if deyiminin koşul ifadesi kısmında karşılaştırmalarda yapılır.Örnek :
    if ($sayi == 5)

    {

    ....

    }

    Yukarıdaki ifadede $sayı değişkenindeki değerin 5'e eşit olup olmadığı sınanmaktadır. == göstergesi eşitlik anlamındadır. Buna benzer şekilde büyük ve küçüklük sınamaları da yapılır. Ör:
    if ( $sayi > 5 ) ..

    Bu kullanımda sınama sonucu ne ise ona göre işlem yapılır.
    Örneğin, sonuç doğru ise oklu parantez içindeki blok icra edilir. Aksi takdirde doğrudan blok dışına atlanır.
    Örnek program : Program adı ifprg2.pl olsun,
    ifprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("Sayı gir:\n");

    $sayi1 = <STDIN>;

    chop ($sayi );

    print ("Başka bir sayı gir:\n");

    $sayi2 = <STDIN>;

    chop ($sayi2);

    if($sayi1 == $sayi2){

    print ("Girilen iki sayı eşit.\n");

    }

    print ("Program sonu.\n");
    Çalışması :
    >ifprg2

    >Sayı gir:

    >17

    >Başka bir sayı gir:

    >17

    >Girilen iki sayı eşit.

    >Program sonu.

    IF ve ELSE kullanarak dallanma:
    Genel format :
    if (koşul)
    {
    Koşul doğruysa icra edilen kısım;
    }
    else{
    Koşul yanlışsa icra edilen kısım;
    }

    Örnek program : program adı ifprg3.pl olsun
    ifprg3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("Bir sayı giriniz:\n");

    $sayi1 = <STDIN>;

    chop ($sayi1);

    print ("Baska bir sayı giriniz:\n");

    $sayi2 = <STDIN>;

    chop ($sayi2);

    if($sayi1 == $sayi2)

    {

    print ("Iki sayı eşittir.\n");

    }

    else

    {

    print ("Iki sayı eşit değildir.\n");

    }

    print ("Program sonu.\n");
    Çalışması ;
    >ifprg3

    >Bir sayı giriniz:

    >17

    >Baska bir sayı giriniz:

    >18

    >Iki sayı eşit değildir.

    >Program sonu.

    >

    ÇOKLU DALLANMA if-elsif-else kullanımı:
    Genel Formatı :
    if (koşul1)

    {

    koşul1 dogru ise icra edilir

    }

    elsif (koşul2)

    {

    koşul2 dogru ise icra edilir

    }

    elsif (koşul3)

    {

    koşul3 dogru ise icra edilir

    ...

    }
    else

    {

    Hiçbir koşul doğu değil ise icra edilir

    }

    Örnek program: Program adı ifprg4.pl olsun
    ifprg4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("Bir sayı giriniz:\n");

    $sayi1 = <STDIN>;

    chop ($sayi1);

    print ("Baska bir sayı giriniz:\n");

    $sayi2 = <STDIN>;

    chop ($sayi2);

    if($sayi1 == $sayi2){

    print ("Sayılar eşit.\n");

    } elsif ($sayi1 == $sayi2 + 1){

    print ("Birinci sayi 1 buyuk.\n");

    } elsif ($sayi1 + 1 == $sayi2){

    print ("Ikinci sayi 1 buyuk.\n");

    }else{

    print ("Sayilar eşit değil.\n");

    }

    print ("Program sonu.\n");
    Çalışması:
    >ifprg4

    >Bir sayı giriniz:

    >17

    >Baska bir sayı giriniz:

    >18

    >Ikinci sayi 1 buyuk.

    >Program sonu.

    >

    Tek satırlı şart ifadesi
    Daha evvel if ifadesini şöyle kullanmıştık,
    if ($var == 0) {

    print ("Bu sıfırdır.\n");

    }

    Bu ifadeyi tek satırda gösterme özelliği de vardır.
    print ("Bu sıfırdır.\n") if ($var == 0);

    her iki örnekte aynı işleve sahiptir.Bu biçim unless,until,while gibi şart ifadelerinde de kullanılır. Ör:
    print ("Bu sıfırdır.\n") unless ($var != 0);

    print ("Henüz sıfır değil.\n") while ($var-- > 0);

    print ("Henüz sıfır değil.\n") until ($var-- == 0);

    Tek satırlı komut kullanımlarında özellikle döngü değeri artış ifadelerinde hata yapma ihtimali olduğundan bu tip ifadeler de dikkatli kullanılmalıdır. Örneğin,
    $count = 1;

    print ("$say\n") while ($say++ < 5);

    ifadelerinde ekrana basılan ilk değer 2 dir.1 değildir. v.b.... Örnek program : Adı:whprg1.pl olsun
    whprg1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $say = 0;

    print ("$say\n")while($say++ < 5);
    Çalışması :
    >whprg1.pl

    1

    2

    3

    4

    5

    >

    FOR DÖNGÜSÜ KULLANIMI
    For döngüsü kullanımını bildiğiniz bir döngü çeşididir. Genel format:
    for (ilk değer ataması; koşul; sayac arttırma) {

    komut satırları bloğu

    }

    Örnekle inceleyelim program adı forprg1.pl olsun
    Çalışması :
    forprg1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    for($sayi=1; $sayi <= 5; $sayi++){

    print ("$sayi\n");

    }

    # 1.ilk değer atanır

    # 5 ten kucuk veye eşit mi? sorusunun cevabı evet ise döngüye girilir

    # sayı yazdırılır

    # sayac 1 arttırılır ve tekrar koşul sınanır.

    # koşul sonucu evet ise işlem bir önceki gibi devam eder,hayır ise döngü dışına çıkılır.
    For dögülerinde bazen her bir değer artışından(döngü sayacı) evvel birden fazla komut uygulamak gerekebilir. Bu durumda for döngüsünde , (virgül) kullanılır. Örneğin aşağıdaki program parçasını inceleyelim ve aynı işlemleri for ile nasıl kullandığımızı görelim.
    $satir = <STDIN>;

    $say = 1;

    while ($say <= 3) {

    print (satir);

    satir = <STDIN>;

    $say++;

    }

    Bu satırlarla yapılanı for ile gerçekleştiren programın kodu aşağıdadır.
    forprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    for($satir = <STDIN>,$say = 1; $say <= 3;

    $satir = <STDIN>,$say++){

    print ($satir);

    }
    FOREACH döngüsü ---- Liste ve Dizi elemanlarını okuma
    Genel formatı:
    foreach localdeğişken (liste-dizi) {

    deyimler grubu;

    }

    foreach dizilerden kolaylıkla eleman almak amacıyla kullanılan, perl'e has bir zenginliktir. Diziden liste elemanı local değişkene atanır.Her dönüşte sıradaki liste elemanı alınır. Bu deyim programlarda çok kullanılır.Örnek program : Program adı forprg2.pl olsun
    forprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    @words = ("Bu", "bir", "liste", "dir.");

    foreach$word (@words){

    print ("$word\n");

    }
    Çalışması:
    >forprg2.pl
    Bu

    bir

    liste

    dir.

    >

    Bir başka örnek program : forprg3.pl program ekrandan girilen satırdaki kelimeleri sıralar ve ters sıraya sokar ve basar.
    forprg3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $line = <STDIN>;

    $line =~ s/^\s+//;

    $line =~ s/\s+$//;

    foreach$word (reverse sort split(/[\t ]+/,$line)){

    print ("$word ");

    }

    print ("\n");
    Çalışması:
    >

    test icin bir satir girdim

    test satir icin girdim bir

    >

    Çalışmanın Açıklaması:Önce split ile satirdaki kelimeler bölünür.
    ("test", "icin", "bir", "satir" , "girdim")

    sonra bunlar sıralanır.(hazır fonksiyon olan sort ile) sıralama sonucu listenin durumu:
    ("bir", "girdim" , "icin", "satir" , "test")

    Bir sonraki aşama da liste ters sırada sıralanır.(reverse hazır fonk.) listenin son durumu: ("test", "satir" , "icin", "girdim" , "bir") olur. Bu durumdaki liste ekrana basılır.
    DO DEYİMİ:
    genel format:
    do{

    deyimler bloğu

    } while_veya_until (şart_ifadesi);

    biçimindedir.
    Örnek kullanım:
    do {

    $line = <STDIN>;

    } while ($line ne "");

    satır sonu değilse döngü devam eder. Aynı sonucu aşağıdaki kodlama da verir.
    do {

    $line = <STDIN>;

    } until ($line eq "");

    Buradaki şart ifadesinde ise satır içeriği boş olana(giriş yok) kadar döngüyü uygular. Örnek program : doprg.pl
    doprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $sayac = 1;

    do{

    print ("$sayac\n");
    $sayac++;

    }until($sayac > 5);
    >doprg.pl

    1

    2

    3

    4

    5

    >

    LAST deyimiöngüden çıkışı sağlar.
    Örnek program: lastprg.pl
    lastprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $toplam = 0;

    while(1){

    $satir = <STDIN>;

    if($satir eq ""){

    last;

    }

    chop ($satir);

    @sayilar = split (/[\t ]+/,$satir);

    foreach$sayi (@sayilar){

    if($$sayi =~ /[^0-9]/){

    print STDERR ("$sayi sayi degil\n");

    }

    $toplam += $sayi;

    }

    }

    print ("Toplam: $toplam.\n");
    Çalışması:
    >lastprg.pl

    4 5 7

    2 11 6

    ^D

    Toplam: 35.

    >

    NEXT deyimi : Döngüde, Bir sonraki dönüşe atlatır.
    Örnek Program: nex.pl
    nextprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("Toplam için son sınır sayısını gir:\n");

    $limit = <STDIN>;

    chop ($limit);

    $say = 1;

    $toplam = $cifttoplam = 0;

    for($say = 1; $say <= $limit; $say++){

    $toplam += $say;

    if($say % 2 == 1){

    # sayı tek ise sonraki dönüşe atla

    next;

    }

    $cifttoplam += $say;

    }

    print(" 1 den $limit ye kadar olan sayıların toplamı: $toplam\n");

    print("Bu sınırdaki çift sayıların toplamı ise: $cifttoplam\n");
    Çalışması:
    >nex.pl

    Toplam için son sınır sayısını gir:

    7

    1 den 7 ye kadar olan sayıların toplamı: 28

    Bu sınırdaki çift sayıların toplamı ise: 12

    >

    Bir başka next örneği içeren program: nex2.pl. Bir kelime sayma programıdır.
    nextprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $toplam = 0;

    while($satir = <STDIN>)# kelime girişi yap, ctrl+d ye basılırsa döngüden çıkılır

    {

    $satir =~ s/^[\t ]*//; # baştaki boşluk ve tabları at

    $satir =~ s/[\t ]*\n$//; # sondaki boşluk,tab ve \n karakterlerini(yeni satır) at

    nextif($satir eq ""); #satır boşsa sonraki dönüşe atla

    @kelimeler = split(/[\t ]+/,$satir);# kelimeleri aralarındaki

    # boşluk ve tab'lardan

    # ayırarak diziye yerleştir

    $toplam += @kelimeler; # dizi boyutundan elde edilen eleman (kelime)

    # sayısı değerini tut

    }

    print ("Toplam kelime sayısı: $toplam\n");
    Çalışması:
    >nex2.pl

    Bir kac kelime girelim

    program kelime sayısını versin.

    ^D

    Toplam kelime sayısı: 8

    REDO DEYİMİ : Döngüdeki bir dönüşü yeniden başlat
    Örnek programla inceleyelim. redoprg.pl
    redoprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $toplam = 0;

    for($say = 1; $say <= 3; $say++){

    $satir = <STDIN>;

    lastif($satir eq "");

    $satir =~ s/^[\t ]*//;

    $satir =~ s/[\t ]*\n$//;

    redoif($satir eq "");

    @kelimeler = split(/[\t ]+/,$satir);

    $toplam += @kelimeler;

    }

    print ("Toplam kelime sayısı: $toplam\n");
    Çalışması:
    >redoprg.pl

    Test satırı.

    Bu da ikincisi.

    ^D

    Toplam kelime sayısı: 5

    >

    VERİLEN ETİKETE GİTME :
    KaSSaS bunu beğendi.

  5. #5
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb

    Bazen dallanmalarda programın herhangi bir bölümüne atlamamız gerekir. Bu bölümlere ulaşmak için bölüme ait etiket adı veriler.Aşağıda kullanılan
    DONE: sintaksı bir etiketi belirler. next ve redo ile de etiket kullanılır. (redo etiket; gibi) .

    Örnek program : etprg.pl
    etprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $toplam = 0;

    $ilksayac = 0;

    DONE: while ($ilksayac < 10)

    {

    $ikincisayac = 1;

    while ($ikincisayac <= 10)

    {

    $toplam++;

    if ($ilksayac == 5 && $ikincisayac == 9)

    {

    last DONE;

    }

    $ikincisayac++;

    }

    $ilksayac++;

    }

    print ("$toplam\n");
    Çalışması:
    >etprg.pl

    59
    >

    CONTİNUE bloğu:
    Örnek görerek anlamaya çalışalım:
    $i = 1;

    while ($i <= 10) {

    print ("$i\n");

    }

    continue { # continue bir blokla kullanılır ({ } arasında)

    $i++;

    }

    Yukardaki örnekte continue bloğundaki $i++ aşağıda for bloğundaki görevi yapar.
    for ($i = 1; $i <= 10; $i++) {


    print ("$i\n");


    }

    Her iki örnekteki çalışma aynıdır.continue genelde while ve until ile kullanılır. for da buna gerek yoktur.
    GO TO etiket deyimi:
    go to yanında belirtilen etikete program akışını yönlendirir. etiket, do veya altyordam(sub) içinde tanımlı olmamalıdır. Ör:
    gotoprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    NEXTLINE: $line =
    ;

    if ($line ne "") {

    print ($line);

    goto NEXTLINE;

    }
    Çalışması:
    bu bir satırdır.

    bu da bir satırdır.

    ^D
    >

    Dosya Listesi
    · ifprg.pl
    · ifprg2.pl
    · ifprg3.pl
    · ifprg4.pl
    · whprg1.pl
    · forprg1.pl
    · forprg.pl
    · forprg2.pl
    · forprg3.pl
    · doprg.pl
    · lastprg.pl
    · nextprg.pl
    · nextprg2.pl
    · redoprg.pl
    · etprg.pl
    · gotoprg.pl

    DÖNGÜLER

    While Döngüsü:
    Koşul ifadesi doğru (true) ise blok içi uygulanır. Değilse blok dışına(sonrasına) çıkılır.
    while ($sayi == 5) {
    print ("Sayı 5!\n");
    }

    Yukarıdaki örnekte koşul ifadesi $sayı değişkeninin 5’e eşitliğini test ediyor. Eğer 5 ise (true) oklu parantez içine (bloğa) geçilerek icra edilir. % değilse (false) blok dışına çıkılır.
    Örnek Program : Program adı wh_dongu1.pl olsun.
    wh_dongu1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $sayi = 0;

    $sayac = 1;

    print ("Bu satır döngü başlamadan evvel yazıldı.\n");

    while ($sayi == 0) {

    print ("Dongu sayac değeri ", $sayac, "\n");

    if ($sayac == 3) {

    $sayi = 1;

    }

    $sayac = $sayac + 1;

    }

    print ("Döngüden çıktık.\n");
    Çalışması :
    >wh_dongu1

    >Bu satır döngü başlamadan evvel yazıldı.

    >Dongu sayac değeri 1

    >Dongu sayac değeri 2

    >Dongu sayac değeri 3

    >Döngüden çıktık.

    >

    Until Döngüsü :
    Genel formatı :
    until (koşul ifadesi) {

    koşul ifadesi sonucu yanlış(true) ise

    blok içi uygulanır

    koşul doğru olunca blok dışına çıkılır

    }

    Örnek Program : Program adı untilprg.pl olsun
    untilprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    print ("17 ARTI 26 SONUCU KACTIR.?\n");

    $dogru_cevap = 43; # Doğru cevap atandı

    $girilen_deger = <STDIN>;

    chop ($girilen_deger);

    until ($girilen_deger == $dogru_cevap) {

    print ("Yanlis! Yeniden dene!\n");

    $girilen_deger = <STDIN>;

    chop ($girilen_deger);

    }

    print ("Bravo..Dogru cevap!!!\n");
    Çalışması :
    >untilprg

    >17 ARTI 26 SONUCU KACTIR.?

    >39

    >Yanlis! Yeniden dene!

    >43

    > Bravo..Dogru cevap!!!

    >

    Dosya Listesi
    · wh_dongu1.pl
    · untilprg.pl
    LİSTE ve DİZİLER

    Listeler:

    Listeler:
    Listeler parantezlerle sınırlandırılmış skalar değerler dizisidir.
    (1, 5.3, "hello", 2)
    Bu listenin 4 elemanı vardır. 1 , 5.3 , hello , ve 2. Elemanı olmayan liste boş listedir
    Ör : ()Ör : (17, 26 << 2) listesi 2 elemanlıdır. 17 ve 104.Ör : (17, $var1 + $var2)
    Bu örnekte 2 elemanlıdır. 17 ve $var1 ve $var2 toplamı.Aşağıdaki kullanımlar listeler için geçerli diğer örneklerdir.
    ("string", 24.3, " string2")($cevap, "cevap $cevap")
    Liste elemanlarını Dizilere yerleştirme:

    Öncelikle dizilerin tanımını görelim. Dizi değişkeni tanımı için o değişkenin başına @ karakteri konur.
    Geçerli Adlandırma Örnekleri:
    @my_array@list2@uzun_isim_de_ kullanılabilir
    Geçerli olmayan adlandırma Örnekleri:
    @1dizi # rakamla başlayamaz@_dizi # alt-tire ile başlayamaz@a.son.dizi # . kullanılamaz
    Aşağıdaki örneği inceleyelim
    $deger = 1;@deger = (11, 27.1, "bir string");
    Burada var isimli değişkenler tamamen farklı değişkenlerdir. $var skalar değişken olup,@var ise dizi değişkenidir.
    Aşağıdaki örnekte, @array bir dizidir ve sırasıyla elemanlarına 1,2,ve 3 atanmıştır.
    @array = (1, 2, 3);
    Dizi elemanlarına erişim:

    Erişim için o elemanın indisi(numarası) verilir.
    Ör: $var = @array[0];
    burada @array dizisinin 1.elemanının indis'i verilerek(Dizilerde ilk eleman numarası 0 dır) o elemanın değerine ulaşılıyor ve değer $var değişkenine atanıyor.D izilerde
    @array[0], 1.elemanı@array[1], 2.elemanı@array[2], 3.elemanı
    temsil eder ve sıralama bu şekilde devam eder. Örnek:
    @array = (1, 2, 3, 4);
    yukarda @array elemanlarına, liste elemanlarının atanmasını görüyoruz. dizi elemanları şu değerleri taşır:
    @array[0], değeri 1@array[1], değeri 2@array[2], değeri 3@array[3], değeri 4
    Bu aşamada aşağıdaki atamayı yapalım.
    $array[3] = 5;
    Şimdi dizi elemanları dizilişi şu şekildedir;
    @array[0], değeri 1@array[1], değeri 2@array[2], değeri 3@array[3], değeri 5yani (1, 2, 3, 5).
    Eğer olmayan dizi elemanı atanmak istenirse veya negatif (-) değer verilirse atanacağı değişken değeri null stringidir ki 0 a eşittir.Ör:
    @array = (1, 2, 3, 4);$skalar = $array[4];
    dizide 5.eleman yani $array[4] yoktur dolayısıyla $skalar değeri null ("") dir. benzer şekilde $skalar = $array[-1]; sonucu da aynıdır. Bir de şu örneği inceleyelim.
    @array = (1, 2, 3, 4);$array[6] = 17;
    Dizinin görünümü şu şekildedir,
    (1, 2, 3, 4, "", "", 17)
    İndis olarak değişken de kullanılır, Ör:
    $index = 1;$skalar = $array[$index]; gibi...
    Dizi elemanlarına erişimde dizi değişkeninin başında $ olduğuna dikkatinizi çekerim. Çünkü dizinin her bir elemanı skalar değişken olarak işlem görür. Ör:
    $sebze[0] doğru @sebze[0] ise yanlış kullanımdır.
    Örnek program: Program adı dizprg.pl olsun
    dizprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @dizi = (1, "tavuk", 1.23, "\"Tamam mi?\"", 9.33e+23); $say = 1; while ($count <= 5) { print ("$say . eleman @dizi[$say-1]\n"); $say++; }Çalısması :
    >dizprg.pl 1 . eleman 1 2 . eleman tavuk 3 . eleman 1.23 4 . eleman "Tamam mi?" 5 . eleman 9.3300000000000005+e23>
    Örnek program: program adı randiz.pl
    randiz.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    # rand() fonksiyonu ile 1- 10 arası random sayı üreten program #!/usr/local/bin/perl $say = 1; while ($say <= 100) { $randnum = int( rand(10) ) + 1; $randtoplam[$randnum] += 1; $say++; } # Herbir sayı için toplamı yaz $say = 1; print ("Herbir sayı için toplam:\n"); while ($say <= 10) { print ("\tsayi $say: $randtoplam[$say]\n"); $say++; }Çalısması:
    >randiz.plHerbir sayı için toplam: sayi 1: 11 sayi 2: 8 sayi 3: 13 sayi 4: 6 sayi 5: 10 sayi 6: 9 sayi 7: 12 sayi 8: 11 sayi 9: 11 sayi 10: 9>
    LİSTE gösterimi:

    (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) gösterimi ile (1..10) gösterimi aynıdır. (2, 5..7, 11) örneğinden anlaşılan ise şudur: listenin 5 elemanı vardır 2,5,6,7,11 String ifadeler içinde aynı kullanım geçerlidir Ör:
    ("aaa", "aab", "aac","aad") ifadesi şu şekilde de gösterilebilir.
    ("aaa".."aad").
    Benzer şekilde; ("BCY", "BCZ", "BDA", "BDB") ifadesi ("BCY".."BDB"), ile aynıdır. @alphabet = ("a".."z"); ifadesi bir alfabe listesini gösterir.
    Örnek program: Program adı lstprg.pl olsun.
    lstprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Baslangic numarasini gir:\n"); $basla = <STDIN>; chop ($basla); print ("Bitis numarasini gir:\n"); $bitis = <STDIN>; chop ($bitis); @liste = ($basla..$bitis); $say = 0; print ("Liste yaziliyor:\n"); while ($liste[$say] != 0 || $liste[$say-1] == -1 || $liste[$say+1] == 1) #burada liste dizisinin sonu ve liste #elemanı icinde 0 var mı kontrolu yapılıyor { print ("$liste[$say]\n"); $say++; }Çalısması:
    >lstprg.pl Baslangic numarasini gir: -2 Bitis numarasini gir: 2 Liste yaziliyor -2 -1 0 1 2>
    Ornek program : Program adı dizprg2.pl
    dizprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @dizi1 = (14, "ekmek", 1.23, -7, "su"); @dizi2 = @dizi1; $say = 1; while ($say <= 5) { print("eleman $say: $array1[$say-1] "); print("$dizi2[$say-1]\n"); $say++; }Çalışması :
    >dizprg2.pl eleman 1: 14 14 eleman 2: ekmek ekmek eleman 3: 1.23 1.23 eleman 4: -7 -7 eleman 5: su su>
    Aşağıdaki kullanım şeklini inceleyelim. Ör :
    @liste1 = (2, 3, 4);@liste2 = (1, @liste1, 5);
    Sonuçta @liste2 dizisinin içeriği (içerdiği liste) şu şekildedir.
    (1,2,3,4,5)
    Örnek program : Program adı dizprg3.pl
    dizprg3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @al = " asla "; @yaz = ("Ben", @al, "kaybetmem!\n"); print @yaz;Çalışması :
    >dizprg3.pl Ben asla kaybetmem!>
    Aşağıdaki parantez kullanımını inceleyiniz
    $ali = "Ali";print (("Hey, " . $ali . "!\n") x 2);
    Bu kodlama sonucu çıktı şöyle olur;
    Hey, Ali! Hey, Ali!
    Dizilerde yerine koyma:

    Şu örneğe bakalım.
    @a = (1, 2, 3);print (@a, "\n");
    Çıktı
    > 123
    Burada bir problem var gibi... Bir de şuna bakın,
    @a = (1, 2, 3);print ("@a\n");
    Çıktı
    > 1 2 3
    Böyle olacaktı..farkı belirleyen kodlamayı inceleyin
    LİSTENiN UZUNLUĞUNU ELDE ETME:

    @a = (1, 2, 3);$skalar = @a;
    Bu kodlama şekliyle biz @a dizisinin(oluşturan listenin) uzunluğunu elde ederiz. $skalar içindeki bu değer 3 tür.
    $skalar = @a;($skalar) = @a; yukarıdaki satırlar farklıdır. 1.satırda $skalar,@a dizisinin uzunluğunu tutar. 2.satırda $skalar,@a dizisinin ilk elemanını tutar.

    Dizilerle çalışmayı iyice anlamak için aşağıdaki programların kodlanışlarını iyi inceleyiniz.
    Örnek program : Program adı dizprg4.pl
    dizprg4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @dizi = (14, "Peynir", 1.23, -7, "elma"); $sayi = 1; while ( $sayi <= @dizi) { print("eleman $sayi: @dizi[ $sayi-1]\n"); $sayi++; }Çalışması:
    >dizprg4.pleleman 1: 14eleman 2: Peynireleman 3: 1.23eleman 4: -7eleman 5: elma>
    Alt dizilerin kullanımı:

    Örnek program : Program adı dizprg5.pl
    dizprg5.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @dizi = (1, 2, 3, 4); @altdizi = @dizi[1,2]; # dizinin 2 ve 3 .elemanından alt dizi olustu. # hatırlayınız...dizinin 1.elemanı indisi $dizi[0] dır. print ("Altdizinin 1.elemanı: $altdizi[0]\n"); print ("Altdizinin 1.elemanı: $altdizi[1]\n");Çalışması:
    >dizprg5.plAltdizinin 1.elemanı: 2Altdizinin 2.elemanı: 3>
    Örnek program : Program adı dizprg6.pl
    dizprg6.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @dizi = ("bir", "iki", "üç", "dört", "beş"); @sira = (1, 2, 3); @altdizi = @dizi[@sira]; print ("Dizi dilimi: @altdizi\n");Çalışması :
    >dizprg6.plDizi dilimi: iki üç dört>
    DİZİ dilimlerine ATAMA:

    @a [0,1] = ("string", 46);
    bu örnekte @a dizisinin ilk 2 elemanı değeri string ve 46 olur. Ör : aşağıdaki satır sonucu
    @a [0..2] = ("string1", "string2");
    3.eleman null stringtir.
    Ör : Aşağıda ise listenin 4.elemanı diziye atanamaz(dikkate alınmaz).
    @a [0..2] = (1, 2, 3, 4);
    Örnek program : program adı dizprg7.pl
    Çalışması:
    >dizprg7.pl a1 b2 b3 a4>
    Örnek program: Program adı dizsort.pl
    dizsort.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #Okunan değerleri sıraladıktan sonra basan örnek #!/usr/local/bin/perl #giriş işlemi print ("Değerleri giriniz\n"); print ("çıkış için boş satır giriniz.\n"); $say = 1; $gir = <STDIN>; chop ($gir); while ($gir ne "") { @a [$say -1] = $gir; $say++; $gir = <STDIN>; chop ($gir); } # sıralama işlemi $say = 1; while ($say < @a) { $x = 1; while ($x < @a) { if ($a [$x - 1] gt $a [$x]) { @a [$x-1,$x] = @a [$x,$x-1]; } $x++; } $say++; } #basma işlemi print ("@a\n");Çalışması:
    >dizsort.pl Değerleri giriniz çıkış için boş satır giriniz. fok bebek dil bal bal bebek dil fok>
    Standart giriş (klavye ) den dizi okuma: giriş dizi değişkenine yapılır. Ör:
    @a = <STDIN>;
    Örnek program : program adı dizkey.pl
    dizkey.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @a = <STDIN>; print (@a);Çalışması:
    >dizkey.pl 1.satır 2.satır son satır. ^D (control ve D tuşu) 1.satır 2.satır son satır.>
    DİZİ KÜTÜPHANE FONKSİYONLARI:

    Dizilerde sıralama:
    Bu işlem için kullanılan fonksiyon sort() dur.
    liste = sort (array); @array = ("Bu", "bir", "test", "dir");
    dizi bu şekilde oluştu. Şimdi sort ile sıralayalım;
    @array2 = sort (@array);
    sonuçta @array2 dizisi içeriği listesi şu şekildedir.
    ("bir", "bu", "dir", "test")
    @array dizisi içeriği ise değişmez...aynıdır.("Bu", "bir", "test", "dir")
    veriler alfabetik değilse;
    @a = (70, 100, 8);@a = sort (@a);
    o zaman sıralama şöyle gerçekleşir.
    (100, 70, 8)
    Dizi değişken veya listeleri ters sıraya sokma: Bu işlemi reverse() fonksiyonu yapar.Örnek:
    @a = ("bal", "incir", "arı", "sinek");@a2 = reverse(@a);
    @a2 içeriği listesi şu şekildedir:
    ("sinek", "arı", "incir", "bal")
    Örnek program: program adı tersdiz.pl
    tersdiz.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #program klavyeden girilen bilgileri ters olarak # (alfabetik olarakbuyukten kucuğe) sıralar #!/usr/local/bin/perl @input = <STDIN>;; @input = reverse (sort (@input)); print (@input);Çalışması :
    >tersdiz.pl fal bal dil bez ^D fal dil bez bal>
    DİZİLERDE chop() FONKSİYONU:

    chop() fonk.nun son karakteri sildiğini biliyoruz. Ör :
    $a = "Ala";chop ($a);
    $var içeriği şu anda "Al" dır.
    Dizi listelerinde kullanımı:
    @list = ("Aslan", "12345", "Geyik");chop (@list);
    Şu an @list içeriği liste şu şekildedir: ("Asla", "1234", "Geyi") Başka bir örnek:
    @a = <STDIN>;chop (@a);
    Bu şekilde klavyeden kullanımda yeni satır karakteri yok edilerek diziye alınır.
    STRİNG LİSTESİNDEN TEK STRİNG OLUŞTURMA:

    Bu görevi join() fonksiyonu yerine getirir. Ör:
    $string = join(" ", "bu", "bir", "liste", "dir");
    $string içeriği şudur: "bu bir liste dir" join da ilk " " kısmı stringler arasında kullanılacak karakteri bildirir. Yukarda ki örnekte bu karakter boş stringtir. Aşağıdaki örneğe bakınca daha iyi anlayacaksınız.
    $string = join("::", "kelime", "ve", "sütun");
    sonuçta oluşan $string stringinin içeriği
    şöyle görünür : "kelime::ve::sütun"
    Bir başka örnek:
    @liste = ("Bu", "bir");$string = join(" ", @list, "stringdir");

    $string içeriği : "Bu bir stringdir" olur.
    Örnek Program: program adı joprg.pl
    joprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl @gir = <STDIN>; chop (@gir); $string = join(" ", @gir); print ("$string\n");Çalışması:
    >joprg.pl Ben perl öğrenmeye basladım. ^D Ben perl öğrenmeye basladım.>
    STRİNGLERİ AYIRMA:

    split()fonksiyonu: join tersi işlev görür. stringler arası karakter iki adet / karakteri arasında belirtilir.
    $string = "bu::bir::ayırma::örneği";@dizi = split(/::/, $string);
    sonuc olarak @dizi içeriği şu şekildedir:
    bu","bir","ayırma","örneği")
    bununla ilgili bir kelime sayma programını inceleyelim
    program adı kesay.pl olsun
    kesay.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $kelimesay = 0; $gir = <STDIN>; while ($gir ne "") { chop ($gir); @dizi = split(/ /, $gir); $kelimesay += @dizi; $gir = <STDIN>; } print ("Toplam kelime sayısı: $kelimesay \n");Çalışması:
    >kesay.pl bu ilk satır bu da ikincisi son satır da bu olsun. ^D Toplam kelime sayısı: 11>
    Şimdi de son öğrendiklerimizi içeren bir örnek : Klavyeden girilen kelimeleri ters sırada yerleştirip yazalım. Program adı fnk.pl
    fnk.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl # Klavyeden girişini yap @giris = <STDIN>; chop (@giris); # Her bir satırdaki kelimeleri ters sırada yerleştir $satir = 1; while ($satir <= @giris) { @kelime = split(/ /, $giris[$satir -1]); @kelime = reverse(@kelime); $giris[$satir -1] = join(" ", @kelime, "\n"); $satir ++; } #şimdi onların sırasını ters cevir ve yazdır @giris = reverse(@giris); print (@giris);>fnk.pl bir iki üç dört beş altı. ^D altı. beş dört üç iki bir>
    Dosya Listesi

    · dizprg.pl
    · randiz.pl
    · lstprg.pl
    · dizprg2.pl
    · dizprg3.pl
    · dizprg4.pl
    · dizprg5.pl
    · dizprg6.pl
    · dizsort.pl
    · dizkey.pl
    · tersdiz.pl
    · joprg.pl
    · kesay.pl
    · fnk.pl



    BİLEŞİK DİZİLER

    Giriş
    Bu diziler normal dizilerde,dizi elemanlarının bilinememesi ihtiyacını karşılamak amacıyla tanımlanmışlardır.
    Örneğin : @dizi dizisinin 1.elemanı $dizi[1] dir ve içeriğini bilmek ise zordur. Oysa ki bileşik dizilerde elemanda bulunan değerin kendisi indistir. $dizi[1] içeriği muz değerini taşıyor olabilir ve bu değeri dışardan anlamak zordur. Bileşik dizide ise $dizi{"muz"} gösterimi vardır. Yani değer indistir. Bu da bir çok kolaylığı beraberinde sunar.
    Öncelikle bileşik dizilerin tanımından başlayalım. Normal dizi tanımında dizi değişkeni adının başında @ karakteri vardı(@meyvalar ...gibi). Bileşik dizi değişkeninin başındaki karakter ise % karakteridir. Bir meyvalar isimli bileşik dizi tanımlayacak olursak, %meyvalar şeklinde kodlarız. Bir diğer fark ise normal dizilerde indis [] karakterleri içinde ifade edilirken bileşik dizilerde { } karakterleri içinde gösterilir. İndiste kullanılacak değerler skalar değer ve değişken adları olabilir.
    $personel_sicil{14159}

    $meyva{"kara_yemis"}

    $reel{3.14159}

    $tamsayi{-7}

    $meyva{$meyva_adi}

    yukarıdaki örneklerin hepsi geçerlidir ve bizlere büyük bir kullanım kolaylığı sağlar.
    BİLEŞİK DİZİLERE ELEMAN ATAMA VE EKLEME
    Atama şekli normalde aşağıdaki gibidir.
    $meyva{"elma"} = 1;

    burada %meyva bileşik dizisinin elma elemanına 1 değeri atanıyor.
    Örnek Program : Ekrandan meyva adı ve numarası girelim(nar mutlaka olsun). Enter basınca nar adlı meyvanın numarasını bassın. Adı ass1.pl
    assl.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl

    $girilen = <STDIN>;

    $girilen =~ s/^\s+|\s+\n$//g;

    %meyva = split(/\s+/, $girilen);

    print ("Nar numarası: $meyva{\"nar\"}\n");
    Çalışması:
    >ass1.pl

    elma 1 armut 2 nar 3 ayva 4

    Nar numarası: 3

    >

    Bir başka örnek program : Bu program da ekrandan girilen satırlarda bulunan büyük harfle başlayan kelimeler ve adetleri bulunur ve basılır. Program adı : ass2.pl
    ass2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    while ($girilensatır = <STDIN>) {

    while ($girilensatır =~ /\b[A-Z]\S+/g) {

    $kelime = $&;

    $kelime =~ s/[;.,:-]$//; # noktalamalar siliniyor.

    $kelimelistesi{$kelime} += 1;

    }

    }

    print ("Buyuk harfli kelimeler ve sayıları:\n");

    foreach $buyukharfli (keys(%kelimelistesi)) {

    print ("$buyukharfli: $kelimelistesi{$buyukharfli}\n");

    }
    Çalışması :
    >ass2.pl

    Bu bir Giris satırıdır.

    Bu satırlarda Buyuk harfler vardır.

    ^D

    Buyuk harfli kelimeler ve sayıları:

    Bu: 2

    Giris: 1

    Buyuk: 1
    >

    BİLEŞİK DİZİLERİ OLUŞTURMA
    Bu diziler tek bir atama ile oluşturulabilir ve daha sonra eleman ilavesi yapılabilir.
    %meyvalar = ("elmalar", 17, "narlar", 9, "incirler", "yok");

    [ veya perl5 e ait bir atama özelliği olarak
    %meyvalar = ("elmalar" => 17, "narlar" => 9,

    "incirler" => "yok"); ]

    komutuyla oluşturulan bileşik dizinin index elemanları ve onların değerleri
    elmalar, 17,

    narlar, 9,

    incirler,yok

    şeklindedir
    %meyvalar dizisine daha sonra elemanı eklemek istersek, mesela, $meyvalar{"kiraz"} = 5; kodunu gireriz.Bu kodlama ile meyvalar isimli bileşik diziye, yeni bir eleman (indexi kiraz ve buradaki değer olarak ta 5) atanmış olur. Normal dizilerden de bileşik dizi oluşturabiliriz. Örneğin,
    @meyvalar = ("elmalar", 6, "kirazlar", 8, "muzlar", 11);

    %meyvalar = @meyvalar;

    satırları incelendiğinde bu işlemin nasıl gerçekleştiği anlaşılacaktır. Benzer mantıkla bileşik diziden de bileşik dizi oluşturulabilir.
    %meyvalar2 = %meyvalar1;

    ve pek kullanışlı olmamakla birlikte(dizi elemanlarının sırası belirlenmediğinden), bileşik diziden de normal dizi oluşturulabilir.
    %meyvalar = ("elmalar", 6, "kirazlar", 8, "muzlar", 11);

    @meyvalar = %meyvalar;

    hatta aynı anda diziler ve skalar değişkenlere birlikte de atama yapılabilir.($degisken1, $degisken2, %bilesikdizi) = @dizi; ...gibi.. yukarda @dizi nin 1.elemanı $degisken1, 2. elemanı ise $degisken2,ye atanır. Sonraki elemanlar ise %bilesikdizi ye atanırlar.
    Örnek Program : Program girilen satırı split fonksiyonu ile bölerek bileşik dizi oluşturur. Program Adı:ass3.pl
    ass3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    $girilensatir = <STDIN>; #satır girişi:
    (meyva adı ve değeri şeklinde)

    $girilensatir =~ s/^\s+|\s+\n$//g; #baştaki ve sondaki boşluklar ayıklanır

    %meyva = split(/\s+/, $girilensatir); #satır kelimelere bölünüp,diziye

    #elemanlar olarak atanır

    print ("Muz sayısı: $meyva{\"Muz\"}\n");
    Çalışması :
    >ass3.pl

    Nar 5 Elma 7 Muz 11 Kiraz 6

    Muz sayısı: 11

    >

    Diziye eleman eklemeyi görmüştük.Bu dizilerden eleman silmek için TEK YOL hazır fonksiyon olan delete kullanımıdır.(Bazı fonksiyonlar çeşitli silme işlemleri yaparlar ama bazı durumlarda karışıklığa yol açılabilir) Ör:
    delete($meyva{"Muz"});

    satırı ile %meyva bileşik dizisinden Muz elemanı(indexi) silinir.
    DİZİ İNDEXLERİNİ VE DEĞERLERİNİ LİSTELEME
    Bileşik dizilerin indexlerini keys fonksiyonu elde eder.
    %meyva = ("nar", 9,

    "muz", 23,

    "ayva", 11);

    @meyvaindex = keys(%meyva);

    Yukardaki şekilde kodlanan satırların sonucu olarak,keys hazır fonksiyonu,%meyva bileşik dizisinin indexleri olan nar,muz ve ayva yı @meyvaindex dizisine atar. Bu atamayı alfabetik sırada yapmak istersek sort fonksiyonunu da eklememiz gerekir Ör:
    @meyvaindex = sort keys(%meyva);

    Bileşik dizilerin indexlerini keys fonksiyonu elde eder demiştik değerlerini ise values hazır fonksiyonuyla elde ederiz.
    %meyva = ("nar", 9,

    "muz", 23,

    "ayva", 11);

    @meyvaindex = values(%meyva);

    @meyvaindex dizisinin elemanları; (9, 23, 11) dir.
    Bir Bileşik dizinin elemanlarına döngü şeklinde erişim (tüm elemanlarına sırayla erişim). Bu işlem için daha önce gördüğümüz keys ve foreach kullanılabileceği gibi, each hazır fonksiyonuda kullanılabilir. Örnek:
    %kayit = ("Mavis", 16, "Arif", 27, "Dinc", 51);

    foreach $tut (keys(%kayit)) {
    .
    .
    .
    # sonraki satırlar
    }

    Arif, Mavis, ve Dinc ,$tut değişkenine atanırlar.
    Bu yöntemle indexlere erişildi ama değerlere erişemedik. Değerlere erişim için de yine aynı mantıkla yeni bir foreach döngüsü kullanmamız gerekir. Ama perl bu kullanımın yerine işimizi çok daha kolaylaştıracak olan each fonksiyonuna sahiptir. Bu fonksiyonla hem index hem değeri elde etmek mümkündür. Ör:
    %kayitlar = ("Mavis", 16, "Arif", 27, "Dinc", 51);

    while (($tut, $kayit) = each(%kayitlar)) {

    # satırların devamı

    }

    yukarda ilk satırda index ve değerler den oluşan bileşik dizi elemanları,diziyi oluştururlarken while döngüsünün her dönüşünde bu diziye ait index ve değer çifti skalar değişkenlere atanır. $tut, indexi, $kayit ise değeri alır. (ilk dönüşte bunların değerleri Mavis ve 16 dır. Sonraki dönüşlerde aynı kurala göre işler).
    Dosya Listesi
    · assl.pl
    · ass2.pl
    · ass3.pl
    DOSYA İŞLEMLERİ

    Dosya Açma:

    Biçimi :
    open (dosyadeğişkeni, dosyaadı);
    dosyadeğişkeni : Dosyanın basvuracağı, kullanmak istediğiniz isim.Herhangi bir harf,rakam ve _ karakterlerinden oluşur. İlk karakter harf olmalıdır.Aşağıdakiler geçerli adlardır.
    MY_NAMENAME2A_REALLY_LONG_FILE_VARIABLE_NAME
    Aşağıdakiler ise geçerli değildir.
    1NAMEA.FILE.NAME_ANOTHERNAMEif
    dosyaadı : Açılacak dosyanın makine içindeki yeri ve adı Örnek:
    open(FILE1, "file1");
    burada işlem yapılacak dosya file1 dir. Ona başvuruyu temsil eden isim ise FILE1 dir. Perl file1' açacağını anlar ve onu FILE1 ile birleştirir. programda FILE1 adı kullanıldığında file1' i temsil eder. Eğer değişik bir dizindeki file kullanılacaksa yolu tam verilmelidir.
    open(FILE1, "/home/ertan/rehber.dat");
    gibi...
    Dosya Açılma biçimleri:

    Dosya kullanım amacına göre 3 şekilde açılır.
    1. Okuma amacıyla
    2. Yazma amacıyla
    3. Ekleme Amacıyla
    1.Okuma için açma modu : Var olan bir dosya okuma amaçlı açılır.
    Ör : open(READFILE, "/home/ertan/rehber.dat");
    2.Yazma için açma modu ( > ) : Mevcut olmayan,ilk defa oluşturulacak dosyalar bu mod ile açılır. Eğer mevcut bir dosya bu modda açılırsa içeriği tamamen silinir ve yeniden oluşur.
    open (OUTFILE, ">/home/ertan/rehber.dat");
    3.Ekleme için açma modu ( >> ) : Var olan bir dosya yazma(var olan kayıtlara ekleme) amacıyla açılır.
    open (APPENDFILE, ">>/home/ertan/rehber.dat");
    Önemli Notlar:
    · Bu modlardan default olanı okuma modudur.
    · Bir dosya yazma modunda açılırsa içeriği tamamen silinir.
    · Aynı anda aynı dosyaya hem okuma hemde yazma işlemi yapamazsınız.
    · Ekleme moduyla açtığınızda sadece ekleme yapabilir ama o dosyadan o anda okuma yapamazsınız.
    · Eğer standart giriş (klavyeden dosyayayazılma) kullanılacaksa(<STDIN> <STDIN>; için açma (open) işlemi yapılmaz.
    Dosya Açma işleminin doğruluk kontrolü:

    Bu işlem için if, unless gibi deyim ve fonk.lar kullanılırak kontrol yapılır. Eğer hata varsa dönen değer 0 dır.Hata yoksa 0 olmayan eğer döner. Dosya test operatörlerini daha sonra işleyeceğiz. Örnek :
    if (open(DOSYAM, "/home/ertan/dosya")) { # file başarı ile açıldığında if bloğu içi # olan bu kısım işlenir }# dosya açılmamışsa burası işlenir.
    Dosyadan okuma biçimi :
    Dosyayı temsil eden ad <> karakterleri içersinde gösterilir.
    $kayit = <DOSYAM>;
    gibi..
    Bu komutla DOSYAM ile temsil edilen dosyadan bir kayıt(satır) okunur ve $kayit skalar değişkenine atanır.
    ÖRNEK PROGRAM osyadan kayıt okuyup ekrana basan program Adı dosya1.pl olsun.Kullanacağımız dosyanın adı bilgi.dat ve içeriğinin de, Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt. şeklinde olduğunu varsayalım.
    dosya1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl if (open(DOSYAM, "bilgi.dat")) { $kayit = <DOSYAM>; while ($kayit ne "") { print ($kayit); $kayit =<DOSYAM>; } }Çalışması :
    >dosya1.pl Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt.>
    die() FONKSİYONU ile PROGRAM SONLANDIRMA İŞLEMİ:

    Herhangi bir durumda programdan çıkış işlemi yapılacaksa die() fonksiyonunu kullanabiliriz. Bu fonksiyonun yazım formatı: die (mesaj); şeklindedir. Ör:
    die ("Program işleyişi durdu!\n");
    komutu kullanılmışsa program aşağıdaki mesajla kesilir.
    Program işleyişi durdu!
    Şimdi Örnek bir programda bunu kullanalım program adı dosya2.pl programda yine bilgi.dat dosyası ile işlem yapalım...
    dosya2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(DOSYAM, "bilgi.dat")) { die ("bilgi.dat dosyası açılamadı!!!\n"); } # yukardaki unless bloğu yerine şu şekilde de kodlama yapabilirdik. # #open (DOSYAM, "bilgi.dat") || die ("bilgi.dat dosyası açılamadı!!!"); # # # Program akışı bu satıra geldiyse dosya açıldı demektir $kayit = <DOSYAM>; while ($kayit ne "") { print ($kayit); $kayit = <DOSYAM>; }Çalışması:
    >dosya2.pl Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt.> Eğer bilgi.dat dosyası yok veya bozuk olsaydı o zaman die ile başlayan satırları içeren blok devreye girer ve programın işleyişi,bilgi.dat dosyası açılamadı!!! mesajı ile kesilirdi.

    programda unless () fonksiyonu kullanıldığını da gördünüz. Ne işe yaradığını programı dikkatle incelerseniz anlayacaksınız.die fonksiyonu ile hangi satırda hata verdiğini de yazdırabiliriz. Sondaki \n karakterini kaldırmamız gerekir. Örnekleri inceleyerek kullanım farkı sonuçlarını anlayalım.
    die ("Dosya bulunamadı\n");
    Çıktısı : Dosya bulunamadı
    die ("Dosya bulunamadı");
    Çıktısı : Dosya bulunamadı at dosya2 line 14.
    dosya2 programın adıdır.(program adı dosya2.pl ise).
    DOSYADAN dizilere OKUMA:

    Genel formatı: @array = <DOSYAM>; şeklindedir. Bunu örnek programda inceleyelim. Dosyanın tamamı bir diziye okunacak ve ekrana basılacaktır. Program adı dosya4.pl olsun ve bilgi.dat kullanılsın.
    dosya4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(DOSYAM, "bilgi.dat")) { die ("bilgi.dat dosyası açılamadı!!!\n"); } @okuyandizi = <DOSYAM>; #Bir üst satırda dosyanın tamamı dizi elemanları olarak diziye alınır #dizi listesi görünümü şu şekildedir #("Bu ilk kayıttır.\n" ....>burası $okuyandizi[0],yani dizinin ilk elemanı # "İkinci kayıt.\n" ....>burası $okuyandizi[1],yani dizinin ikinci elemanı # "Dosyadaki son kayıt.\n") ....>burası $okuyandizi[2],yani dizinin üçüncü elemanı # aşağıda ise ekrana basılır. print (@okuyandizi);Çalışması :
    >dosya4.pl Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt.>
    DOSYALARA YAZMA İŞLEMİ :

    Dosya yazma amaçlı (yazma ve ekleme) açılır. Sonrada yazdırma komutu uygulanır. Örneğin;
    open(DOSYAM, ">bilgi.dat");
    ile açılır
    print DOSYAM ("Bu ilk kayıttır.\n");
    komutuylada satır yazılır. Yukarda ki kodlama sonucu bilgi.dat içeriği şöyledir ;
    Bu ilk kayıttır
    Bir örnek program yapalım. Program adı dosya5.pl olsun. İki dosya kullanalım veren.dat ve bilgi.dat. veren.dat'tan okutup bilgi.dat'a yazılsın. veren.dat dosyası içeriği şöyle olsun;
    Bu ilk kayıttır.İkinci kayıt.Dosyadaki son kayıt.
    dosya5.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(VEREN, "veren.dat")) { die ("veren.dat dosyası açılamadı!!!\n");} unless (open(DOSYAM, ">bilgi.dat")) { die ("bilgi.dat dosyası açılamadı!!!\n"); } $kayit = <VEREN>; # veren.dat'tan bir satır,$kayit değişkenine aktarılır. while ($kayit ne "") { # veren.dat kayıtları bitti mi? Bittiyse blok dışına çık. print DOSYAM ($kayit); # $kayit değişkeninde ki satır bilgi.dat'a yazdırılır. $kayit = <VEREN>; # veren.dat'tan bir satır,$kayit değişkenine aktarılır. } print("Aktarma işlemi tamamlandı !!!"); # tırnak içindeki mesaj ekrana yazdırılır.Çalışması:
    >dosya5.plAktarma işlemi tamamlandı !!!veren.dat dosyasının içeriği aynen bilgi.dat dosyasına aktarılır ve sonuçta her iki dosya içeriği de aşağıdaki görünümde olup aynıdır.
    Bu ilk kayıttır.İkinci kayıt.Dosyadaki son kayıt.
    STANDART ÇIKTI DOSYASI:

    Standart çıktı dosyası tıpkı standart girdi dosyası gibi sistem fonksiyonudur. Standart girdi(<STDIN> klavyeden girişi temsil ediyordu. Standart çıktı aygıtı ise ekrandır. Standart çıktı aygıtına yazdırma işlevini <STDOUT>; komutu görür. Şu iki satırın işlevi aynıdır.
    print ("Here is a line of output.\n");print STDOUT ("Here is a line of output.\n");
    dolayısıyla print STDOUT... kullanımına gerek yoktur. Perl bu işi otomatikman yapar.
    DOSYA BİRLEŞTİRME merge)

    İki dosyadan okuttuğumuz satırlardan yeni bir dosya oluşturma: Bir çok değişik mantıkla yapılabilir. Mesela iki dosyadan okutulan satırları standart output (ekran) dosyasına yazan bir program. program adı dosya6.pl, okutulacak dosyalar dosya1 ve dosya2 olsun
    dosya1 kayıtları: dosya2 kayıtlarıa1 b1a2 b2a3 b3
    ekrana (standart çıktı dosyasına) şu şekilde yazsın istiyoruz varsayalım,
    a1 b1 a2 b2 a3 b3
    Çalışması:
    >dosya6.pl a1 b1 a2 b2 a3 b3
    Dosya giriş çıkış fonksiyonları

    Temel giriş çıkış fonksiyonları open, close, print, printf, write fonksiyonlarıdır. Bunları görmüştük . Hatırlayalım ve biraz daha inceleyelim.
    Open Fonksiyonu : Dosya erişimi sağlar.
    open (DOSYAM, "/u/ertan/dosya.txt");
    open, default olarak okuma amaçlı dosya açar.İlk defa açılan dosyaya yazmak için > kullanılır.
    open (DOSYAM, ">/u/ertan/dosya.txt");
    Mevcut dosyaya eklemek için ise >> kullanılır;
    open (DOSYAM, ">>/u/ertan/dosya.txt");
    Ayrıca
    open (MAIL, "|mail ertan");
    şeklinde pipe ile kullanımını da görmüştük.
    open fonksiyonu bunlardan başka daha birkaç çeşit dosya açma biçimi kullanır. Aşağıdaki kullanım bunlardan birisidir.
    open (CAT, "cat dosya*|");
    burada open, unix'teki cat dosya* komutunu icra eder. | işareti dosya adından sonra yazılır. Buradaki komutla adı dosya ile başlayan tüm dosya isimleri bir dosyaya listelenir. Bu dosya bir giriş dosyası gibidir ve CAT dosya değişkeni kullanılarak erişilebilir. Örnek : pipe'lı komutla unix'teki w komutu çıktısını giriş olarak alma
    w komutu çıktısını aşağıda görüyorsunuz.Programı ona göre inceleyiniz.
    ertan> w 11:09am up 30 days, 2:31, 3 users, load average: 0.06, 0.07, 0.01 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT ftpadmin ttyp3 darkness.anadolu Wed 1pm 12:22m 0.12s 0.12s -bash poyraz ttyp4 192.168.100.59 8:56am 0.00s 0.58s 0.07s pine ertan ttyp0 192.168.100.9 9:52am 0.00s 0.29s 0.02s w
    program.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl 2: # w çıktısından saat ve o an için bağlı olan kullanıcıları alalım 3: open (WOUT, "w|"); # w komutu çıktısı WOUT tarafından alınır 4: $saat = <WOUT>; # WOUT ' un ilk satırını okur(yani aşağıdaki satır) #(11:09am up 30 days, 2:31, 3 users, load average: 0.06, 0.07, 0.01) 5: $saat =~ s/^ *//; #baştaki boşlukları çıkarır 6: $saat =~ s/ .*//; # ilk kelimeden sonraki her şeyi çıkartır(sondaki newline hariç). #Kısaca 5. ve 6. satırlar saat'i(11:09am) elde eder. $saat =~ s/pm|am$//; #Not: sondaki -am- veya -pm- gösterimini kaldırmak istersek bu satırı ekleriz. 7: <WOUT>; #WOUT dan ikinci satırı okur bu satır bizim için gereksizdir. Aşağıdaki Başlık satırını atlat(geç) işlevi gerçekleşir. #[USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT] 8: @kullanicilar = <WOUT>; #kalan satırlar @kullanicilar dizisine okunur. 9: close (WOUT); #WOUT dosyasıyla işimiz bitti.Sistem kaynaklarını tüketmemek için kapattık. 10: foreach $kullanicilar (@kullanicilar) {#@kullanicilar'ın her bir elemanı, kullanıcı bilgisinin 1 satırını içerir. 11: $kullanicilar =~ s/ .*//; # programımız, bu satırın ilk kelimesine(kullanıcı adı) ihtiyaç duyar# .Bu yüzden 10,11 ve 12: } #12 satırlarda döngü tamamlanınca newline hariç her şey temizlenir dizide sadece kullanıcı listesi bulunur. 13: print ("Saat: $saat "); 14: print ("Halen bagli olan kullanicilar:\n"); 15: $oncekikullanici = ""; 16: foreach $kullanici (sort @kullanicilar) { #kullanıcılar alfabetik sıralanıyor 17: if ($kullanici ne $oncekikullanici) ##Birden fazla aynı kullanici bağlantısı varsa, $oncekikullanici son basılan #kullanici adını tutar. Ve $kullanici içindeki değer, $oncekikullanici ile aynı ise basılmaz 18: print ("\t$kullanici"); # ve uygun ise basılır 19: $oncekikullanici = $kullanici; 20: } 21: }çalışması;
    ertan> ./program.pl Saat: 11:24 Halen bagli olan kullanicilar: ertan ftpadmin poyraz
    DOSYADAN DOSYAYA YÖNLENDİRME

    Unix' te standart error ve standart çıktıyı aynı dosyaya yönlendirir. sh komutu olarak şöyle yazılır.
    $ program >dosya1 2>&1
    Aşağıdaki program standart çıktı ve standart error dosyalarının yönlendirilişiyle ilgili bir örnektir. Örnek :
    standartprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    çalışması; programın ekrana çıktısı yoktur.Çıktı Yazdir isimli dosyayadır. Yazdir isimli çıktı dosyasının içeriği şöyledir.
    Satir 2 Satir 1
    Sıralı yazmadığını gördük çünkü işletim sisteminin özelliğinden dolayı değerler buffer' dadır ve buradan önce STDERR ' e yazar. Bu problemi çözmek istersek dosya için buffer' ı kullanmama işlemi yapılır. Önce select ile dosya seçilir. Sonra $| sistem değişkenine 1 atanır. Eğer $| değişkenine 0 olmayan değer atanırsa buffer kullanılmaz. Tıpkı $~ ve $^ gibi $| da son kullanılan dosyaya etkilidir ki o dosya select ile son seçilendir. Eğer select kullanılmamışsa STDOUT'dur.
    Şimdi $| kullanarak önceki örnekten farklı olarak sırayla yazan programı görelim. Örnek :
    standartprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl open (STDOUT, ">Yazdir") || die ("STDOUT dosya acma hatasi"); open (STDERR, ">&STDOUT") || die ("STDERR dosya acma hatasi"); select (STDOUT); $| = 1; #buffer'ı kapat.Seçilen dosya yazdırma kanalını aç,seçilen dosya bir önceki satırda belirlendi:STDOUT. # Not: Aslında STDOUT default dosya olduğundan onu select ile seçmeye gerek yoktu sadece $| = 1; yeterliydi. print STDOUT ("Satir 1\n"); print STDERR ("Satir 2\n"); close (STDOUT); close (STDERR);Yazdir dosyası içeriği aşağıdaki gibidir.
    Satir 1 Satir 2
    OKUMA VE YAZMA ERİŞİMİ TANIMLAMA

    Okuma ve yazma erişimi ile dosyayı açmak için dosya adından önce +> kodlanır.
    open (OKUYAZ, "+>dosya.dat");
    KaSSaS bunu beğendi.

  6. #6
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb

    OKUMA VE YAZMA ERİŞİMİ TANIMLAMA

    Okuma ve yazma erişimi ile dosyayı açmak için dosya adından önce +> kodlanır.
    open (OKUYAZ, "+>dosya.dat");
    bu erişimle dosyanın bir kısmının üzerine yazma hakkı almış olursunuz. Bu tip kullanımlarda en verimli çalışma seek ve tell fonksiyonlari ile birlikte gerçekleştirilir. Bunlar dosyada karakter(ler) atlama işlevi sağlar. İlerde inceleyeceğiz.
    ayrıca +< eki' de okuma ve yazma amaçlı tanımda kullanılabilirler.
    open (OKUYAZ, "+<dosya.dat");
    < eki okuma amaçlı tanımdır bu demektir ki aşağıdaki iki örnek aynıdır.
    open (OKU, "<dosya.dat"); open (OKU, "dosya.dat");
    close Fonksiyonu : dosya kapatır. Eğer | ile komut şeklinde kullanıldıysa (open (DOSYA, "cat dosya*|"); ) gibi O takdirde komut bitene kadar program bekler. print, printf, write Fonksiyonu : Bunları görmüştük.
    select Fonksiyonu : Bir dosyayı default yapmak için kullanılır. Bunu da görmüştük.
    eof Fonksiyonu : Dosya sonunu kontrol eder. Okunacak kayıt kalmamışsa 0 olmayan değer döndürür. Eğer okunacak kayıt varsa 0 döndürür. <> işaretlerinden etkilenir. eof and eof() farklıdır. eof nin <> işaretlerden nasıl etkilendiği görülür. Aşağıdaki örnekte bu durumu gözleyebiliriz. Örnek programda komut satırından isimleri verilen dosyalar(1 veya daha çok)'ın içeriği basılır. dosya1 içeriği şöyle olsun;
    Bu ilk dosyanın ilk satırı Bu ilk dosyanın ikinci satırı
    Dosya2 içeriği ise ;
    Bu ikinci dosyanın ilk satırı Bu ikinci dosyanın ikinci satırı
    Örnek : eof ve <> birlikte kullanımı;
    eof.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl while ($kayit = <>) {#<>operatörü der ki; adları komut satırında verilen dosyalardan ,okunmakta olanın sıradaki satırını oku print ($kayit); # ve yazdır. if (eof) { #dosya sonu geldiyse aşağıdaki mesaji bas print ("-- Kullanımdaki dosyanın Sonu --\n"); } }çalışması; ./program.pl dosya1 dosya2 Bu ilk dosyanın ilk satırı Bu ilk dosyanın ikinci satırı -- Kullanımdaki dosyanın Sonu -- Bu ikinci dosyanın ilk satırı Bu ikinci dosyanın ikinci satırı -- Kullanımdaki dosyanın Sonu -- dosya sonu kontrolünde eof ve eof() kullanılır ama ikisi birlikte kullanılmaz.

    Şimdi de parantezli eof kullanımına bakalım.Örnek :
    eof2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl while ($kayit = <>) { print ($kayit); if (eof()) { print ("-- Kullanımdaki dosyanın Sonu --\n"); } }çalışması ;
    ./program.pl dosya1 dosya2 Bu ilk dosyanın ilk satırı Bu ilk dosyanın ikinci satırı Bu ikinci dosyanın ilk satırı Bu ikinci dosyanın ikinci satırı -- Kullanımdaki dosyanın Sonu --
    Çıktıyı incelediğinizde dosya sonu mesajının her dosyanın sonunda değil tüm dosyaların okunması Sonunda bir defa yazdığını görüyorsunuz. eof() kullanımında ancak tüm dosyalar bitince true döner. Birinci dosya sonunda kontrolde false 'e döner. Çünkü sırada okunacak ikinci dosya vardır. Yalnız şuna dikkat etmemiz gerekir eof ile eof() arasında sadece <> operatörüyle kullanımda fark vardır. Yalnız başlarına kullanımda eof ile eof() arasında fark yoktur.
    DOSYA İSİMLERİNİN DOLAYLI KULLANIMI

    $dosya = "DOSYAM"; open ($dosya, ">dosya.dat"); gibi...
    Örnek :
    dosyakopya.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl &dosya_ac("OKU", "", "dosya1"); &dosya_ac ("YAZ", ">", "dosya2"); while ($satir = &dosyadan_oku("OKU")) { &dosyaya_yaz("YAZ", $satir); } sub dosya_ac { local ($dosya_degiskeni, $dosya_modu, $dosya_adi) = @_; open ($dosya_degiskeni, $dosya_modu . $dosya_adi) || die ("$dosya_adi dosyası açılamadı... "); } sub dosyadan_oku { local ($dosya_degiskeni) = @_; <$dosya_degiskeni>; } sub dosyaya_yaz { local ($dosya_degiskeni, $satir) = @_; print $dosya_degiskeni($satir); }çalışması, program ekrana çıktı vermez. dosya1 adlı dosyayı dosya2 ye kopyalar. more dosya1 veya cat dosya1 gibi komutlarla baktığımızda her iki dosyanın da içerik olarak aynı olduğunu görürüz.
    $ cat dosya1 Bu ilk dosyanın ilk satırı Bu ilk dosyanın ikinci satırı $ cat dosya2 Bu ilk dosyanın ilk satırı Bu ilk dosyanın ikinci satırı
    DATALARI ATLAMA VE YENİDEN OKUMA

    == seek == == tell ==
    Şimdiye kadar hep ilk sıradan başlatarak okuma örnekleri gördük. Perl bize iki hazır fonksiyon sunar.Bunlar seek ve tell fonksiyonlarıdır. Bu fonksiyonlar dosyada ileri, geri hareketi veya tekrar okuma gibi işlevlere sahiplerdir.
    seek fonksiyonu : bu fonksiyon dosya içinde ileri ve geri hareketi sağlar. Formatı ;
    seek (dosyadeğişkeni, atlanacak karakter sayısı, konum_sabiti);
    eğer konum sabiti;
    0 ise; dosya başı 1 ise; bulunulan konum değeri 2 ise; dosya sonu anlamı taşırlar.
    Örneğin; DOSYAM adlı dosyanın başına atlamak istiyorsak
    seek (DOSYAM, 0, 0);
    kodlanır. Aşağıdaki ifade bulunulan karakter pozisyonundan 80 byte (karakter) ileri atlar.
    seek (DOSYAM, 80, 1);
    aşağıdaki ifade ise 80 karakter geri gider.
    seek (DOSYAM, - 80, 1);
    dosya sonuna atlamak için ise;
    seek (DOSYAM, 0, 2);
    seek başarılı olursa true(0 olamayan değer) aksi takdirde false(0) döndürür. seek ,tell fonksiyonu ile çok sık kullanılır.
    tell Fonksiyonu : Mesafe döndürür.
    Bu mesafe dosya başı ile bulunulan pozisyon(bir sonra okunacak satır bölgesi) arası mesafedir.Birimi byte' dır. Formatı;
    tell (dosya_değişkeni);
    o an kullanılacak olan dosyanın adını saklayan değişken örneğin DOSYAM ' ın kullanım anındaki pozisyonunu elde eden kodlama şu şekilde yazılır.
    $pozisyon = tell (DOSYAM);
    seek ve tell kullanımı örneği içeren bir program yazalım. Çalışacağımız dosyanın adı dosya1 ve içindeki kayıtlar şöyle olsun;
    Ertan TURKMEN ANKARA TURKIYE JOE ROSE NEWYORK USA ŞAZİYE MORAL ISTANBUL TURKIYE DANIYAR ANDICAN TASKENT OZBEKISTAN
    Örnek:
    seek_ve_teel.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl open (GECICI_DOSYA, "dosya1"); print "Dosya yazdırılıyor ..!\n\n"; print "DOSYANIN ILK KAYDI--"; while (1) { $satir = <GECICI_DOSYA>; last if ($satir eq ""); print ($satir); if (eof()) { print "DOSYA SONU\n"; last; } $pozisyon = tell(GECICI_DOSYA); $pozisyon++; print "--Yeni SATIR--Dosyada $pozisyon.karakterdeyiz\n"; print "5 karakter sonrası: "; seek (GECICI_DOSYA, 5, 1); }çalışması: program.pl
    Dosya yazdırılıyor ..! DOSYANIN ILK KAYDI--Ertan TURKMEN ANKARA TURKIYE --Yeni SATIR--Dosyada 30.karakterdeyiz 5 karakter sonrası: OSE NEWYORK USA --Yeni SATIR--Dosyada 51.karakterdeyiz 5 karakter sonrası: E MORAL ISTANBUL TURKIYE --Yeni SATIR--Dosyada 81.karakterdeyiz 5 karakter sonrası: AR ANDICAN TASKENT OZBEKISTAN DOSYA SONU
    dosya değişkeni pipe (|)' a refere ediyorsa tell ve seek kullanılamaz. Örneğin;
    open (DOSYAM, "cat dosya*|"); olursa aşağıdaki satır anlamsızdır $satir = tell (DOSYAM)
    SİSTEM OKUMA YAZMA FONKSİYONLARI

    Perl' de <DOSYADEGISKENI>şeklindeki ifade dosyadan en temel okuma şeklidir. Bunun dışında dosyadan okuma için iki fonksiyon daha vardır. Bunlar;
    · read : unix' de ki fread fonksiyonu gibidir
    · sysread : read fonksiyonuna eş değerdedir
    Perl yazmak için de fonksiyonlar sunar. Örneğin unix' de ki write' a benzeyen syswrite fonksiyonu gibi.read Fonksiyonu: okuma yapar ve isteğe bağlı karakter sayısını skalar değişkene atar.
    read (dosyadegiskeni, sonucdegiskeni, uzunluk, atlamadegeri);
    okunacak skalar veya okunacak dosya' ı temsil array değişken karakter sayısı eder.(okunan buraya depolanır) Örn:
    read (DOSYAM, $skalar, 80);
    bu çağrı ile DOSYAM' dan 80 karakter(byte) okunur ve $skalar değişkenine depolanır. Eğer DOSYAM dosyasının sonuna gelinirse 0' a döndürür, normalde okunan karakter(byte)leri döndürür. Eğer hata oluşursa read, null string döndürür. read kullanılarak skalar değişkene bir argüman eklenebilir. Bu argüman değişken içinde atlanacak byte sayısını verir. Örn:
    read (DOSYAM, $skalar, 40, 80);
    komutu ile read, DOSYAM' dan bir başka 40 byte okur ve bunu $skalar 'a kopyalarken daha önce depolanmış 80 byte'ı atlar.
    sysread Fonksiyonu : Mümkün olduğunca hızlı data okumak için read yerine sysread kullanabilirsiniz.
    Formatı; sysread (dosyadegiskeni, sonucdegiskeni, uzunluk, atlamadegeri( isteğe bağlı ));
    Örn:
    sysread (DOSYAM, $skalar, 80); sysread (DOSYAM, $skalar, 40, 80); read ile kullanımı aynıdır. sysread UNIX' in read komutu ile aynıdır.

    syswrite Fonksiyonu : Bu fonksiyonda olabildiğince hızlı yazmak için kullanılır. UNIX' deki write komutuyla aynıdır. Formatı:
    (dosyadegiskeni, sonucdegiskeni, uzunluk, atlamadegeri); syswrite (dosyadegiskeni, data, uzunluk, atlamadegeri);
    yazılacak datanın byte atlama dosyayı temsil nerede olarak değeri eder. olduğu uzunluk ( isteğe bağlı )
    Örnek:
    syswrite (DOSYAM, $skalar, 80);
    $skalar' ın 80 byte' ını DOSYAM' a yazar.
    syswrite (DOSYAM, $skalar, 40, 80);
    $skalar' da ki ilk 80 byte' ı atladıktan sonra sonraki 40 byte' ı, DOSYAM' a yazar.
    Geniş bilgi için UNIX' in read ve write komutlarına bakınız.
    getc Fonksiyonu Kullanarak Karakter Okuma : dosyadan bir karakter okur. Formatı;
    $karakter = getc (dosya);
    döndürülen okunacak dosya karakter Örn:
    $tek = getc(dosya);
    dosya' dan tek karakter okur, $tek ' e kopyalar.getc, hotkeys uygulamalarında çok yararlıdır. Örnek :
    getc.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl &hot_keys_baslat; while (1) { $tek_al = getc(STDIN); last if ($tek_al eq "\\"); # \ karakteri giriş sonu olacak $tek_al =~ tr/a-zA-Z0-9/b-zaB-ZA1-90/; # ne yazılırsa bir sonrakini elde eder print ($tek_al); } &hot_keys_son; print ("\n"); sub hot_keys_baslat { system ("stty cbreak"); system ("stty -echo"); } sub hot_keys_son { system ("stty -cbreak"); system ("stty echo"); }Çalısması:
    program çalıştığında siz ne yazarsanız bir sonrakini yazar. Yani a yazarsanız b , 1 yazarsanız 2 gibi...
    -- Programdan çıkmak için \ tuşuna basınız .--
    a1d yazarsak, ekranda b2e görünür. hot_keys_baslat alt programı, hot key girişi için çalışma çevresini düzenler. system fonksiyonu, argüman alır ve icra eder. stty -cbreak, bir anda bir karakter almasını sisteme söyler. stty echo ise yazılan karakterin ekranda görülmemesini söyler. hot_keys_son altprogramı ise normal çalışma moduna döndürür.
    binmode Fonksiyonu :
    bu fonksiyon kullanılarak binary dosya okunur. Format;
    binmode (dosya değişkeni); binmode (DOSYAM); normalde DOS ve benzeri çevrede çalışmadıkça buna ihtiyacınız yoktur.

    Dosya Listesi

    · dosya1.pl
    · dosya2.pl
    · dosya4.pl
    · dosya5.pl
    · program.pl
    · standartprg.pl
    · standartprg2.pl
    · eof.pl
    · eof2.pl
    · dosyakopya.pl
    · seek_ve_teel.pl
    · getc.pl

    FORMATLI YAZDIRMA

    Tanımlama: Aşağıdaki tanım basit bir örnektir.
    format FORMATIM =
    ===================================


    B a s k ı F o r m a t ı d ı r

    ===================================

    syntax:

    format FORMAT_ADI =

    ----

    ---- çıktı satırları

    ----

    ----

    .


    BASKI FORMATINI GÖSTERME
    Bu işlem için iki şeye ihtiyaç vardır. Kullanmak istediğiniz formatı, $~ sistem değişkenine(sistem değişkenlerini göreceğiz), set edin. write fonksiyonunu çağırın. Bununla ilgili bir örnek program görelim.Ör. program:
    format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #! /usr/bin/perl

    $~="FORMATIM";

    write;

    format FORMATIM =

    =====================

    g ö r mek i s t e d i ğ i n i z t e x t

    =====================

    .
    çalıştır ¿
    =====================

    g ö r mek i s t e d i ğ i n i z t e x t

    =====================

    İzah: format adı ( FORMATIM ) sistem değişkenine ($~) atandığında perl şunu anlar. write fonksiyonu kullanıldığında atanan format basılacaktır. Son kısımda ise formatın tanımlanması vardır.
    eğer $~ sistem değişkenine atanma olmasaydı, yazdırma işlemi standart çıktıya (STDOUT) olacak şeklinde algılanacaktı.

    BASKI FORMATINDA DEĞERLERİ GÖSTERME
    Tabi ki bu işlemin amacı değişken ve dizilerdeki değerlerin uygun biçimde yazdırılmasıdır. Ör. programSesli harfleri bulur sayar ve basar)
    format2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1:#!/usr/local/bin/perl

    2:

    3: while ($kayit = <STDIN>) {

    4: $kayit =~ s/[^aeiou]//g;

    5: @sesliler = split(//, $kayit);

    6: foreach $sesli (@sesliler) {

    7: $seslisayisi{$sesli } += 1;

    8: }

    9: }

    10: $~ = "SESLIFORMAT";

    11: write;

    12:

    13: format SESLIFORMAT =

    14: ================================================== ========

    15: text içindeki sesli adedi:

    16: a: @<<<<< e: @<<<<<

    17: $seslisayisi {"a"}, $seslisayisi {"e"}

    18: i: @<<<<< o: @<<<<<

    19: $seslisayisi {"i"}, $seslisayisi {"o"}

    20: u: @<<<<<

    21: $seslisayisi {"u"}

    22: ================================================== ========

    23: .
    çalıştırılır¿
    Bu bir sesli harf bulma testidir.

    Kartal Cimbomu yendi.

    ^D

    ================================================== ========

    text içindeki sesli adedi:

    a: 4 e: 3

    i: 6 o: 1

    u: 3

    ================================================== ========

    çalışması: satır girilir.
    4. satırda; a,e,i,o,u dışındakiler elenir
    5. satırda; kalanlar(sesli) @sesliler dizisine aktarılır.
    6. satırda; sesliler sayılır (@sesliler dizisi test edilerek) ve %seslisayisi bileşik dizisine eklenir.
    10. satırda; basım formatı SESLIFORMAT olarak Set edilir.
    Değer alanları formatları için tanımlanan değerler hakkında 3 şeyi not etmeliyiz.

    · alanların içerikleri basılır.
    · alan boşluklarını hizalamaya gerek yoktur.
    · alanlar bir üst satırda tanımlı formata uygun tanımlanırlar.
    DEĞER ALANI FORMATI SEÇİMİ
    Geçerli değer alanı formatları tablosu
    Alan
    Değer Alan Formatı
    @<<<
    sola dayalı baskı
    @>>>
    sağa dayalı baskı
    @|||
    merkeze dayalı baskı
    @##.##
    sabit noktalı sayısal baskı
    @*
    çok satırlı text

    @* haricinde tüm tanımlarda alan ölçüsü tanımlı karakter sayısı kadardır. Bu sayıya @ karakteri dahildir.

    Örneğin;
    · @>>>> tanımı 5 karakter uzunluğu belirtir. Benzer şekilde
    · @##.## uzunluğu 6 dır(. da dahil)
    ÇOK SATIRLI ALAN FORMATI KULLANIMI
    Ör prog.
    coksatirli_format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    @kayit = <STDIN>;

    $karakterler = join("",@kayit);

    $~ = "SATIRLAR";

    write;

    format SATIRLAR =

    ****** Girdiğiniz dosyanin icindekiler: ******

    @*

    $karakterler

    *****************************************

    .
    çalıştır:
    program.pl ¿

    ilk satir

    ikinci satir

    ucuncu satir

    ****** Girdiğiniz dosyanin icindekiler: ******

    ilk satir

    ikinci satir

    ucuncu satir

    *****************************************

    2. satır file'ın tamamını @input dizisine atar. Her bir satır dizinin bir elemanı olarak yerleşir.
    3. satır girilen satırları tek karakter stringi olarak $stringe birleştirerek yerleştirir. Bu karakter stringi newline karakterlerini de içermektedir.
    6. satır formatı çağırarak bastırır . @*tanımı çok satırlı text olarak formatlar.
    DİĞER ÇIKTI DOSYALARINA YAZMA
    Şu ana kadar write fonksiyonu ile standart çıktı dosyasına yazılma örnekleri gördük. Diğer dosyalara da yazdırabiliriz. En kolayı write'a argüman olarak file'ı geçirmektir. Örneğin DOSYAM ile temsil edilen dosyaya yazmak için (DOSYAM print formatı kullanarak) şu ifadeyi kullanırız; write (DOSYAM);
    Bu örnekte DOSYAM file adı ve format adı olarak kullanılıyor bu düzenli ve hoştur ama bazı kısıtlamaları vardır. Böyle bir durumda $~ kullanılamaz.(print format seçimi için). $~ sistem değişkeni default file değişkeniyle çalışır. O da write ile çıktıya gönderilir. default file variable'nı değiştirmek böylece $~ da etkin file'ı değiştirmek için hazır select fonksiyonu kullanılır.
    select (DOSYAM);

    Select kullanım için default file değişkenini set eder. Örneğin; file değişkeni DOSYAM ile temsil edilen, dosyaya yazmak amacıyla FORMATIM print formatını kullanmak için;
    select(DOSYAM);

    $~ = "FORMATIM";

    write;

    kodlamak gerekir. Bu kodlama ile FORMATIM formatı DOSYAM değişkeni ile birleştirilmiş oldu. Bundan sonra write artık bu dosyaya yazdırmaya başlar. Eğer tekrar standart çıktıya yazdırmak istersek
    select(STDOUT);

    komutunu kodlarız.
    select kullanımı sadece write ' a değil print ' e de etki eder.

    Select fonksiyonu çok kullanışlı olup aynı altyordamla aynı anda birden fazla dosyaya yazdırma imkanı sağlar. Örnek programda bunu görebiliriz.
    select_format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl

    2:

    3: open (DOSYA1, ">dosya1");

    4: $karakterler = "Denemeler";

    5: select (DOSYA1);

    6: &kayityaz;

    7: select (STDOUT);

    8: &kayityaz;

    9: close (DOSYA1);

    10:

    11: sub kayityaz {

    12: $~ = "KAYITYAZ";

    13: write;

    14: }

    15:

    16: format KAYITYAZ =

    17: CIKTI DOSYALARIMA@<<<<< YAZIYORUM.

    18: $karakterler

    19: .
    çalışması:
    program.pl¿

    CIKTI DOSYALARIMADeneme YAZIYORUM.

    Yukardaki satır hem ekrana hem de dosya1 isimli dosyaya yazar.
    select ve $~ rastgele kullanılmaz format takibini kaybedebiliriz. Aşağıdaki örnekteki gibi kullanım uygundur .
    select (DOSYAM);

    $~ = "FORMATIM";

    write;

    DEFAULT FİLE DEĞİŞKENİNİ SAKLAMAK (SAVE) .
    Select son seçilen file değişkeninin içeriğini tutar. Örneğin;
    $eskidosya = select(YENIDOSYA);

    select ($eskidosya);

    şeklindeki kullanımla da önceki dosya lazım olduğunda kullanılabilir. Select ile seçim işini bir alt programla yapar ve programın geri kalanını etkilemede kullanabilirsiniz. Aşağıdaki örneği bu amaçla kullanabilirsiniz, inceleyin.
    sub standarta_yaz {

    local ($dosyasakla, $formatsakla);

    $dosyasakla = select(STDOUT);

    $formatsakla = $~;

    $~ = "FORMATIM";

    write;

    $~ = $formatsakla;

    select($dosyasakla);

    }

    Bu alt program default olarak STDOUT set etmek için select'i çağırır. select'in dönüş değeri önceki default file' dır ve $dosyasakla içine saklanmıştır. Sonraki adım STDOUT' a yazmak için kullanılan printformatı save etmektir. Altyordam bunu, $~ halihazırdaki değerini $formatsakla değişkenine saklayarak yapar ve sonra altprogram, FORMATIM 'ı printformatı olarak set eder..(o an kullanımda olacak printformat olarak) write çağrıldığında artık standart output dosyasına FORMATIM formatını kullanarak yazar.
    Birinci adım; $~' i $formatsakla içindeki değere resetlemek, son adımda $dosyasakla içindeki file' ı default output olarak set etmektir.
    SAYFA BAŞLIK AYARI
    dosyaadı_TOP

    örnek:
    format STDOUT_TOP =

    Ertanlar Kollektif Şirketi

    .

    yukarıda tanımdaki format her sayfa başına yazacaktır. Bu alanda değişkenlerde kullanılabilir(diğer format tanımlarında olduğu gibi) sayfa başlarına yazılan sayfa numaralarını sistem değişkeni olan $% tutar. örnek:
    format STDOUT_TOP =

    Sayfa @<<.

    $%

    .

    bu tanımla mesela 1.sayfa basılırken sayfanın üzerindeki baskı şöyle çıkar.
    Sayfa 1.

    BAŞLIK BASKI FORMATINI DEĞİŞTİRME
    Bu işlem için $^ sistem değişkeni kullanılır. $~ de olduğu gibi default file değeri değişir. Örneğin; başlık formatı olarak BASLIGIM baskı formatını ve başlık file ' ı olarak ta DOSYAM ' ı kullanmak için şu ifadeleri ekleriz.
    $eskidosya = select(DOSYAM);

    $^ = "BASLIGIM";

    select($eskidosya);

    .

    SAYFA UZUNLUĞU ARALIĞI
    Bu iş için $= sistem değişkeni kullanılır. Default değer 60 satırdır. Mesela 66 satıra ayarlamak için şöyle yazarız.
    $= = 66;

    bu atama ilk write' dan önce yapılmalıdır.sayfa ortasında böyle bir ayar yapılırsa sonraki sayfadan geçerli olur. Baskı ve uzunluk ayarı ve formatı kullanan program örneği aşağıdadır. Ör11.08
    uzunluk_ayari.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl

    2:

    3: open (BASKI, ">dosya.dat"); #çıktı file' ı tanımlandı.

    4: select (BASKI);

    5: $~ = "SATIRYAZ"; #çıktı formatı(OUTFILE için) bu atama sayfa başlığını #içermez.

    6: $^ = "TOP_OF_PAGE"; #OUTFILE için satır başlığı formatı belirlendi.

    7: $= = 60; #satır ayarı 60 olarak belirlendi.

    8: while ($satir = <STDIN>) {

    9: write;

    10: }

    11: close (BASKI);

    12:

    13: format TOP_OF_PAGE =

    14: - sayfa @<

    15: $%

    16: .

    17: format SATIRYAZ =

    18: @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    19: $satir

    20: .
    çalışması: program.pl ¿

    bu bir satirdir

    bu ise ikinci satirdir

    son satir da bu olsun bakalim.

    ^D

    $ more dosya.dat (dosya.dat içeriğini görelim)

    - sayfa 1

    bu bir satirdir

    bu ise ikinci satirdir

    son satir da bu olsun bakalim.

    UZUN KARAKTER STRİNGLERİN FORMATI
    @* multiline text karakteri ile çok satırı alt alta yazdırmıştık ama bunda formatlama yoktu. Düzgün basım formatı için başlangıçtaki @ yerine ^ karakteri kullanırız.Örnek rogram.pl
    string_format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl

    2:

    3: $string = "Bu\ndengesiz satır\nörneğidir.\n";

    4: $~ = "OUTLINE";

    5: write;

    6:

    7: format OUTLINE =

    8: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<

    9: $string

    10: .
    çalışması: program.pl ¿

    Bu dengesiz satır
    8.satırda ^ yerine @^kullanılsaydı çıktı şöyle olurdu.
    Bu

    dengesiz satır

    örneğidir.

    Şimdi çok satırlı, formatlı bir örnek görelim.
    coksatirli_string_format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl

    2:

    3: @aktarma = <STDIN>;

    4: $aktarma = join("",@aktarma);

    5: $~ = "ALINTI";

    6: write;

    7:

    8: format ALINTI =

    9: Günün sözü:

    10: -----------------------------

    11: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    12: $aktarma

    13: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    14: $aktarma

    15: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    16: $aktarma

    17: -----------------------------

    18: .
    çalışması:
    program.pl ¿

    Etkin bir programlama dili

    programcinin eli ayagidir sihirli bir asadir.

    ^D

    Günün sözü:

    -----------------------------

    Etkin bir programlama dili programcinin eli ayagidir

    sihirli bir asadir.

    -----------------------------


    FORMATLAMA ANINDA BOŞ SATIRLARI ELEMEK
    Bu işlev için yukardaki örnekteki 11,13,15. satırların en başına ~ karakteri konur.Diğer kısımlar aynıdır.
    11: ~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    12: $aktarma

    13: ~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    14: $aktarma

    15: ~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    16: $aktarma

    BELİRSİZ SAYIDA SATIR GİRMEK.
    Bunun içinde ~~ sembolü kullanılır.
    belirsiz_satir_format.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    1: #!/usr/local/bin/perl

    2:

    3: @aktarma = <STDIN>;

    4: $aktarma = join("", @aktarma);

    5: $~ = "ALINTI";

    6: write;

    7:

    8: format ALINTI =

    9: Günün Notu :

    10: -----------------------------

    11: ~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<

    12: $aktarma

    13: -----------------------------

    14: .
    çalışması: ¿

    bir başarılı proglamlama dili

    iyi dizayn edilmişse büyüden farksızdır.

    ^D

    ÇIKTI FORMATLAMADA printf
    Aşağıdaki argümanlar printf ' ye geçirilir.
    1. Bir veya fazla alan tanımlayıcı içeren basılacak string
    2. Basılacak string de görülecek her alan için bir değer.
    Alan tanımlayıcıları tablosu aşağıdadır. % işaretiyle kullanılırlar.
    %c
    tek karakter
    %d
    10 tabanlı integer
    %e
    bilimsel floating-point
    %f
    floating-point (sabit noktalı)
    %g
    floating-point (birleşik format)
    %o
    oktal tamsayı (integer)
    %s
    string
    %u
    işaretsiz tamsayı
    %x
    16 tabanlı integer

    Örn:
    printf("Bastırmak istediğim sayı : %d.\n", $toplam);

    printf ' ile ilgili bazı özellikler
    · eğer d,o,u,x önüne l (le) koyarsak Long anlamındadır(uzun integer) %ld gibi... bu durum integer çok rakamlıysa kullanılmalıdır.
    · pozitif tamsayı uzunluk gösterir. Örneğin; %20s ifadesi 20 karakter uzunluğunda string anlamındadır. Ve sağa dayalı yerleşir.
    · eğer negatif sayı ile verilirse alan dolmadığında sola dayalı yerleşir. Örneğin; %-20s sola dayalı 20 karakter (alan dolmazsa)
    · eğer e,f,g kullanıyorsak noktadan sonraki hane sayısını verebiliriz.
    Şöyleki;
    %8.3f

    alan genişliği nokta sonrası
    eğer rakam fazla girilmişse yuvarlama yapılır. Örneğin;
    Tanım değer

    %5.2f 43.499 girilmişse değer 43.50 olur.

    Şu örnekte; %15.10s ise String 15 karakter uzunluğunda bir alana basılacak ama stringin kendisi en fazla 10 karakter uzunluğunda olacak ifadesi vardır. (bu durum basılacak alanda 5 tane boşluk garanti eder).
    printf ile diğer dosyalara da write ' da olduğu gibi yazma işlemi yapılır.
    printf DOSYAM ("Toplam: %d.\n", $toplam);

    Dosya Listesi
    · format.pl
    · format2.pl
    · coksatirli_format.pl
    · select_format.pl
    · uzunluk_ayari.pl
    · string_format.pl
    · coksatirli_string_format.pl
    · belirsiz_satir_format.pl
    STANDART GİRİŞ ÇIKIŞ YÖNLENDİRMESİ:

    Giriş

    Bu işlevi >, < karakterleri sağlar. (Unix'teki gibi) Biliyoruz ki , $line = <>; komutu ile klavyeden bir satır girişi sağlanıyordu. Aynı komutu yazarak istenilen bir dosyadan nasıl giriş sağlayabiliriz. Şöyle; programadı < girisdosya > çıktıdosyaı komutu girildiğinde giriş için değerler girisdosya dosyasından alır ve çıktıyıda print ($line); komutuyla çıktıdosya dosyasına yazar.
    STANDART HATA DOSYASI:

    Buda hazır bir değişken kullanılarak halledilmiştir. Standart hata dosyası <STDERR> dir ve ekranı temsil eder. Ekrana çıkmasını istemezsek başka bir dosyaya yönlendirme ile gönderebiliriz. Örnek program : Standart hata(error) kullanımlı program. dosya adı dosya7.pl olsun
    dosya7.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl open(DOSYAM, "bilgi.dat") || die ("bilgi.dat dosyası açılamadı!!!\n"); print STDERR ("bilgi.dat dosyası başarıyla açıldı !!!.\n"); $kayit = <DOSYAM>; while ($kayit ne "") { chop ($kayit); print ("\U$$kayit\E\n"); # Büyük harfe çevirerek basar $line = <DOSYAM>; }Çalışması: (bilgi.dat dosyası mevcut varsayıyoruz)
    >dosya7.pl bilgi.dat dosyası başarıyla açıldı !!!.> die () fonksiyonu çıktıyı standart output(çıktı) değil standart error(hata) dosyasına yollar. Bu demektir ki die() fonk.mesajları daima ekrana çıkar.

    DOSYA KAPATMA:

    Kullanımı sona eren dosyalar close fonk. ile kapatılır. Örnek:
    close (DOSYAM); # Dikkat ! close (bilgi.dat) değil.
    DOSYA STATÜSÜNÜ BELİRLEME - TEST OPERATÖRLERİ KULLANIMI:

    Statüye karar verme: Dosya işlemlerinde bir çok şeyi test etmeye ve dosya durumunu belirlemeye ihtiyacımız olabilir. Örneğin: Dosya mevcut mu? text dosyası mı? Okunabilir mi? Boş mu? v.b... Bunları belirlemek için kullanılan operatörler vardır.
    Ör : dosya test operatörü kullanımlı bir program. program adı dosya8.pl olsun.Açılmamış bir dosyanın varlığını test ediyor.
    dosya8.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(DOSYAM, "bilgi.dat")) { if (-e "bilgi.dat") { # -e dosya test operatörüdür. # Dosya mevcut mu? test eder. die ("bilgi.dat dosyası mevcut ama açılamadı!!!.\n"); } else { die ("bilgi.dat dosyası mevcut değil!!!.\n"); } } $kayit = <DOSYAM>; while ($kayit ne "") { chop ($kayit); print ("\U$kayit\E\n"); $kayit = <DOSYAM>; }Çalışması: (varsayalım ki dosya mevcut olmasın)
    >dosya8.pl bilgi.dat dosyası mevcut değil!!!> -e yanındaki ifadede değişken de kullanılabilir
    $var = "file1";if (-e $var) ....
    veya
    $var = "file1"; if (-e $var . "a") gibi.. (burada file1a isimli dosya sözkonusu)
    perl, if (-e $var . "a") ifadesini . karakterinin(stringte birleştirme) önceliğinden dolayı karıştırmaz. string'te tam yol da belirtilebilir.Ör:
    if (-e "/u/ertan/bilgi.dat") ... gibi....
    Operatör
    İzah
    -d
    Dosya bir dizin mi?
    -e
    Dosya mevcut mu?
    -f
    Dosya normal (sıradan) dosya mı?
    -l
    Dosya sembolik link mi?
    -o
    Dosyanın sahibi kullanıcı mı?
    -r
    Dosya okunabilir dosya mı?
    -s
    Dosya boş olmayan dosya mı?
    -w
    Dosya yazılabilir dosya mı?
    -x
    Dosya çalıştırılabilir dosya mı?
    -z
    Dosya boş dosya mı?
    -B
    Dosya bınary dosya mı?
    -O
    Dosya sahibi sadece kendi gerçek kullanıcısı mı?
    -R
    Dosya sadece kendi gerçek kullanıcısı tarafından mı okunabilir?
    -S
    Dosya socket mi?
    -T
    Dosya text dosya mı?
    -W
    Dosya sadece kendi gerçek kullanıcısı tarafından mı yazılabilir?
    -X
    Dosya sadece kendi gerçek kullanıcısı tarafından mı çalıştırılabilir?
    gerçek kullanıcı:loginden girilen kullanıcı adı

    Örnek program: program adı dosya9.pl. Program yazma amaçlı bir dosya açarken mevcut mu kontrolü yapar.
    dosya9.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(OKUNACAK_DOSYA, "okunandosya")) { die ("okunandosya adlı dosya açılamadı.\n"); } if (-e "yazilandosya") { die ("Halihazırda yazilandosya adlı bir dosya var.\n"); } unless (open(YAZILACAK_DOSYA, ">yazilandosya")) { die ("yazilandosya adlı dosya açılamadı.\n"); } $kayit = <OKUNACAK_DOSYA>; while ($kayit ne "") { chop ($kayit); print YAZILACAK_DOSYA ("\U$kayit\E\n"); $kayit = <OKUNACAK_DOSYA>; }Çalışması:
    >dosya9.pl Halihazırda yazilandosya adlı bir dosya var. > Eğer yazilandosya olmasaydı,okunandosya kayıtları(satırları) yazılandosya adlı dosyaya Büyük harflere çevrilerek aktarılacaktı.

    Örnek program parçası : Dosya üzerinde okuma hakkı var mı? test eder. Program Adı dosya10.pl dosya.txt dosyasının varolduğunu ama okuma hakkı olmadığını varsayalım.
    dosya10.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl unless (open(DOSYAM, "dosya.txt")) { if (!(-e "dosya.txt")) { die ("dosya.txt isimli dosya bulunamadı.\n"); } elsif (!(-r "dosya.txt")) { die ("dosya.txt isimli dosyayı okuma hakkınız yok.\n"); } else { die ("dosya.txt açılamadı.\n"); } }Çalışması:
    >dosya10.pl dosya.txt isimli dosyayı okuma hakkınız yok. > -r kullanımından önce -e operatörü testine gerek yoktur. Çünkü -r de dosyayı bulamasa yanlış (false) değeri döndürür. -r ve -e nin birlikte kullanım amacı tam olarak hatanın nerede olduğunun tesbiti olabilir.

    Örnek program : Dosya adı :dosya11.pl Dosyanın yazmak için açmadan önce boş olup olmadığını test eden program parçası Dosya var ve dolu olsun varsayalım.
    dosya11.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl if (-e "dosya.dat") { if (!(-w "dosya.dat")) { die (" dosya.dat dosyasına yazma hakkınız yok.\n"); } if (!(-z "dosya.dat")) { die ("dosya.dat dosyası boş değil.\n"); } } # Bu noktada dosya ya boş yada mevcut değildir ve yazma amaçlı açılabilir.>dosya11.pl dosya.dat dosyası boş değil. >
    Örnek Program: Bu program,-s operatörü kullanarak,standart giriş aracılığıyla dosya büyüklüğünü döndürür ve ekrana basar(yazar). Program adı dosya12.pl olsun.
    dosya12.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Dosya adını giriniz:\n"); $dosyaadi = <STDIN>; chop ($dosyaadi); if (!(-e $dosyaadi)) { print ("$dosyaadi adlı dosya mevcut değil.\n"); } else { $size = -s $dosyaadi; print ("$dosyaadi dosyası $size byte içeriyor.\n"); }Çalışması:
    >dosya12.pl Dosya adını giriniz: bilgi.dat bilgi.dat dosyası 128 byte içeriyor. >
    DOSYA DEĞİŞKENLERİYLE TEST OPERATÖRÜ KULLANIMI:

    Ör: Dosya değişkenimiz DOSYAM ise;
    if (-z DOSYAM) { print ("Bu dosya boş!\n"); }
    kodlaması ile DOSYAM ın temsil ettiği (mesela bilgi.dat) dosyanın durumu test edilir.
    DOSYA DİZİSİ OKUMA:

    > program alan.dat bilgi.dat
    ve enter tuşuna basarız bundan sonra program satırları içinde şu şekilde bir kodlama gerekir ki 3 dosyayı da arka arkaya kullanabilelim.
    $liste = <>; ( $liste = <DOSYAM>; kullanımını hatırlayın ve farkı görün)
    işte bu satır sayesinde her bir dosyanın işi bitince diğeri devreye girer. Yukarda ki izahlardan sonra daha iyi anlamak için bir program yazalım ve çalıştırıp işleyişi görelim. Ekrandan adı girilen 2 dosyanın (alan.dat ve bilgi.dat olsun)içeriğini ekrana basan program.
    alan.dat ve bilgi.dat dosyaları içeriği aynıdır ve kayıtları şunlardır:
    Bu ilk kayıttır. İkinci kayıt.
    Dosyadaki son kayıt ve kodladığımız programın adı dosya13.pl olsun.
    dosya13.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl while ($gir = <>;) { # sıradaki dosyadan,sıradaki satır alınıp $gir 'e atanıyor print ($gir); # ve değişken içeriği yazdırılıyor(Son dosyanın sonuna kadar devam eder) }Çalışması:
    >dosya13.pl alan.dat bilgi.dat Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt. Bu ilk kayıttır. İkinci kayıt. Dosyadaki son kayıt. > dosya13.pl komutunu girerken dosya adlarını yazmasaydık standart input(<STDIN>) tan giriş beklerdi.
    Dosya adı DOSYAM ise, <DOSYAM> kullanımını hatırlayalım.

    Skalar değişken kullanarak skalar değişken içeriği ne ise dosya adı olarak onu kullansın İstiyorsak;
    $dosyaadi = "DOSYAM"; $kayit = <$dosyaadi>;
    kodlamasını kullanırız. $dosyaadi değişirse okunacak dosyada değişmiş olur.
    Unix' ten hatırlatma
    $ cp *.pl /u/ertan
    komutu dizindeki .pl uzantılı ne kadar dosya varsa /u/ertan <DIR>'na kopyalar. İşte <> nin, cp komutunun burada birden çok dosyayı elde edip kopyalaması mantığına benzeyen Bir kullanımı vardır. Örneğin;
    @dosyalistesi = <*.pl>;
    kodlaması *.pl olan tüm dosyaları @dosyalistesi dizisine listeler.Döngüde de kullanılabilir. Örneğin;
    while ($kayit = <*.pl>) { print ("$kayit\n"); }
    tüm dosyalar (uzantısı .pl olan) arka arkaya listelenir.
    DİZİLERE OKUTMA:

    Değişkenlere okutma gibidir.Biraz evvel gördüklerimiz uygulanabilir. Tek farkla ki okutulan değişken skalar değişken değil dizi değişkenidir.
    $liste = <DOSYAM>; yerine @liste = <DOSYAM>; kullanırız.
    Bu okutma işleminde dikkatinizi çekmek istediğim önemli bir nokta vardır. Şöyle ki; Bir dosyadan ,Skalar değişkene tek kayıt okunurken( $liste = <DOSYAM>; veya $gir = <>; gibi), dizi değişkenine tum dosya aktarılır( @liste = <DOSYAM>; veya @gir = <>; gibi).
    KOMUT SATIRI ARGÜMANLARINI DEĞER OLARAK GİRME(KULLANMA):

    Önceki programda,
    >dosya13.pl alan.dat bilgi.dat
    komutuyla alan.dat ve bilgi.dat'ı argüman olarak kullanmıştık. Perl bu argümanları değer olarak kullanan hazır bir dizi değişkeni sunar: @ARGV. Elde edilen argümanlar bu dizide dizi elemanlarını içeren bir liste olarak saklanır ve nasıl işimize yarayacaksa o amaca uygun kullanılabilirler.
    Örneğimizden yola çıkarsak, >dosya13.pl alan.dat bilgi.dat kullanımıyla, @ARGV dizisi içeriği ("alan.dat","bilgi.dat") listesi olarak set edilir. Burada $ARGV[0] içeriği "alan.dat",$ARGV[1] içeriği ise "bilgi.dat",dır. @ARGV elemanlari tıpkı diğer dizi değişkenleri gibi karşılıklı atama işlemlerinde kullanılabilirler. Örneğin,
    $var = $ARGV[0]; $ARGV[0] = 43; ...gibi...
    Argüman sayısını elde etmek istersek @ARGV dizisini bir skalar değişkene atarız.
    $arg_sayisi = @ARGV;
    $arg_sayisi skalar değişkenindeki değer argüman sayısını verir.
    Örnek Program : Bu program kelime arar ve sayar. Program adı: dosya14.pl olsun. Programı çalıştırırken alan.dat ve bilgi.dat dosyalarının adlarını ve bu dosyalarda aratacağımız "Bu" kelimesini komut satırından gireceğiz.
    Çalışması :
    >dosya14.pl Bu alan.dat bilgi.dat Aranan Kelime: Bu alan.dat içinde bulunan:1 bilgi.dat içinde bulunan:1 Toplam : 2
    ARGV ve <> Operatörü:

    Gerçekte Perl de, <>; operatörü @ARGV dizisine bir referans (gönderme) içerir. <> görüldüğünde ilk file açılır ve adı $ARGV[0] içine atanır. Bu arada @ARGV içindeki ilk eleman silinir ve sonraki eleman bu ilk elemanın içine yerleşir (kaydırma işlemi- Bunu hazır shift(@ARGV) fonk.yapar
    Örnek Program: <> kullanılan kelime arama ve sayma programı.Adı dosya15.pl
    dosya15.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $aranankelime = $ARGV[0]; print ("Aranacak kelime: $aranankelime\n"); shift (@ARGV); $toplamkelime = $kelimesay = 0; $filename = $ARGV[0]; while ($kayit = <>) { chop ($kayit); @kelimeler = split(/ /, $kayit); $w = 1; while ($w <= @kelimeler) { if ($kelimeler[$w-1] eq $aranankelime) { $kelimesay += 1; } $w++; } if (eof) { print ("$filename: içindede bulunan: "); print ("$kelimesay\n"); $toplamkelime += $kelimesay; $kelimesay = 0; $filename = $ARGV[0]; } } print ("Toplam : $toplamkelime\n");Çalışması :
    >dosya15.pl Bu alan.dat bilgi.dat Aranan Kelime: Bu alan.dat içinde bulunan:1 bilgi.dat içinde bulunan:1 Toplam : 2 >
    LINK (HAT) AÇMA: --pipe--

    Unixte 2 ayri işlemi likleme(piping) işlemi ile birleştirebiliyorduk. Bu işlem için | (pipe) karakteri kullanılıyordu. Bu özelliği perl de kullanır. örneğin aşağıdaki komutla,
    open (MYPIPE, "| cat >hello");
    MYPIPE açıldığında çıktı MYPIPE 'a gönderilir ve girdi cat >hello komutu olur. Aşağıda sistemdeki bir kullanıcıya perl programından mesaj gönderme örneği var.İncelersek daha iyi anlarız.
    open (MESAJ, "| mail ertan"); print MESAJ ("Merhaba Ertan! Bu mesaj perl den mail gönderme denemesidir!\n"); close (MESAJ);
    Bu satırlarda İlkönce open komutuyla MESAJ dosya değişkeniyle , -mail ertan- komutuna bağlantı kurulur. Daha sonra MESAJ adlı dosya değişkeni içeriği olan yazılan mesaj bu hat(bağlantı) ile ilişkilendirilir ve close komutu ile mesajı içeren satır ertan isimli kullanıcıya gönderilir. giden mesajın içeriği:
    Merhaba Ertan! Bu mesaj perl den mail gönderme denemesidir!
    olarak karşı taraftan okunacaktır.
    Dosya Listesi

    · dosya7.pl
    · dosya8.pl
    · dosya9.pl
    · dosya10.pl
    · dosya11.pl
    · dosya12.pl
    · dosya13.pl
    · dosya15.pl

    KOMUT SATIRI SEÇENEKLERİ

    Bir perl programına seçenek geçirmenin iki yolu vardır.
    · Komut satırında
    · Programın ilk satırında
    KOMUT SATIRINDAN SEÇENEK GİRME
    Syntax : Perl seçenek program adı

    Örnek :
    $ perl -s -w test1 c

    komutu ile test1 programı –s ve –w seçeneklerini alır ve çalışır. Bazı seçeneklerde değer alabilir. Örnek :
    $ perl -0 26 test1

    integer

    Aradaki boşluğu (seçeneklerde) kaldırarak da aynı iş yapılır.
    $ perl -026 test1 ...gibi
    $ perl -sw test1 ...gibi

    $ perl -sw026 test1 ...gibi

    PROGRAMDA SEÇENEK TANIMLAMA
    #!/usr/bin/perl -w # perl4 te tek seçeneğe izin var. Perl5 serbest
    # ama bazı sistemler 32 karakterden fazlasını almıyor.
    Komut satırında perl -s test1 ¿ girmişsek programın ilk satırı ise
    #!usr/bin/perl -w

    ise Program çalışırken sadece -s seçeneği ile çalışır. -w dikkate alınmaz.
    SEÇENEKLER
    -v : Perl'in versiyonunu verir.
    $ perl -v test1 ¿

    -c : syntax'ı kontrol eder.
    $ perl -c test1 ¿

    Program çalıştığında test1 syntax ok mesajı verir, hata varsa bildirir.
    -w : Yazım ikazı, program yazımında syntax değilde yazım kullanımı konusunda hata varsa kontrol eder. Mesela yanlış değişken adı veya = = yerine eq kullanılması gibi. Örneğin ; $y=$x; satırına geldik diyelim eğer $x tanımsız ise Identifier main::x ..... şeklinde mesaj verir.(Bunlarla ilgili geniş bilgiyi sonraki bölümlerde inceleyeceğiz.)
    -w ile -c kullanımı hem syntax hem kullanım hatasının tespiti için yararlıdır.

    -e : Tek satır programı icrası (bir satırda birden fazla da kullanılabilir). Örneğin ;
    perl -e "print('Hello');" -e "print('there');" ¿

    Ekrana : Hello there yazar.
    -s : Kendi komut satır seçeneklerinizi tedarik eder. Perl -s test1 -q ¿ program test1'i başlatır ve -q seçeneğini ona geçirir. Eğer -s yazmasaydık -q seçeneği programa geçmezdi. Seçenek tek karakterden fazla olabilir. $sebze değişkenini kullanacaksak
    perl -s test1 -sebze ¿

    gireriz. $sebze'nin değeri 1'dir. (perl otomatikman 1 verir.) veya başka bir değer atama işi şu şekilde yapılabilir.
    perl -s test1 -sebze="nar" ¿

    $ ebze içeriği "nar" olur.
    -P option : C preprocessor kullanma seçeneğidir.
    Perl -P örnekprog ¿ bu komutla örnekprog , C önişlemcisinden den alınır sonra icra için perl'e geçer. C önişlemcisi bize C deki bazı ifadelerini kullanma izni verir. # ile başlarlar.Örnek ;
    # define USER "ertan"

    # define EXPRES (14+6)

    define tanımlı makroya değer geçirir.
    # define bulunan bir perl program örneği :
    Çalışması :
    Bir Internet adresi giriniz:

    194.27.16.7

    Tam adı: sirius.gazi.edu.tr

    Diger adları :
    sir

    sirius

    Define ile ilgili bir başka kullanım :
    #define FIRST 1

    #define SECOND FIRST

    $result = 43 + SECOND; ( yani 43+1)

    #include Kullanarak Diğer Dosyaları Alma :
    #include dosyaadı

    include bir başka C önişlemci komutu olup, tanımlı program parçasını dosya içeriğinine dahil etme işlevi görür. Örnek ; myincfile.h dosyasını dahil etmek için
    #include " incdosyam.h"

    (bu dosya local dizin'de aranır. diğer dizinlerde de aratmak icin -I opsiyonu kullanılır). Verilen patern’de arama için,örneğin;
    #include "/u/pub/incdosyam.h"

    şeklinde kodlanır.
    -I : bu seçenek C include dosyalarını aratır.-P ile birlikte kullanıldığında bu dosyaları hangi dizinde aranacağı belirtilmiş olur.
    perl -P -I /u/home/incdizin dosya

    birden fazla dizinde aratmak için;
    perl -P -I /u/home/incdizin -I //u/home/incdizin2 dosya
    -I ile verilen dizinler @INC içinde saklanır.

    -n : Çoklu dosyalarla işlem seçeneğidir. Birden fazla giris (dosya/satır)okuması yapar.
    Unix'te birçok dosya ile işlem mesela komut satırından yapılabilir. (örneğin;Cat dosya1 dosya2 dosya3 komutu dosya1, dosya2, dosya3 dosyalarını okur ve ekrana basar v.b) Perl’de aynı işi <> operatörü ve döngü yardımıyla yapabiliriz.
    while ($line = <>) {

    ----

    ---- satırlar

    ----

    }

    Bir başka metot da –n kullanımı ile gerçekleştirilir. Bu seçenek, komut satırından birden fazla girdi alır. Konuya ilişkin bir örnek görelim : Bu örnek girilen satırın iki yanına * koyar. Örnek ;
    komutsatiri.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl -n

    # giriş satırı sistem değişkeni olan $_içinde depolanacaktır.

    $line = $_;

    chop ($line);

    printf ("* %-52s *\n", $line);
    Çalışması ;
    -n seçeneği bu programı görünmez bir while döngüsüyle kapatmıştır. Komut satırından girilen değerler $_ içine depolanır. -n ile -e birlikte kullanişlıdır. Örneğin aşağıdaki komut cat komutuna eşittir.
    $ perl -n -e "print $_;" dosya1 dosya2 dosya3

    veya daha basit olarak perl -n -e "print" dosya1 dosya2 dosya3 her üç dosya içeriği alt alta ekrana listelenir. $_ değişkeni default değişkendir. Hatta pattern örneklerde ve yerine koymalarda operatörler $_ üzerinden default işlem yaparlar. Örnek ;
    $ perl -n -e "print if /[0-9]/" dosya1 dosya2 dosya3 ¿

    dosya1, dosya2 ,dosya3 'ü tarar rakam içeren girişleri (satırları) listeler.
    -p : Bu seçenekte -n -e benzer farklı olarak okunan satırları basar.
    $ perl -p -e ";" dosya1 dosya2 dosya3 ¿

    osya1, dosya2, dosya3 içerikleri okunur ve alt alta ekrana basılır. (yukardaki örnek unix'teki Cat dosya1 dosya2 dosya3 komutuyla aynıdır.) -p seçeneği -i ile de çok kullanılır.
    -p ve -n birlikte kullanılırsa, -n dikkate alınmaz.

    -i : Dosya yazma (editing)seçeneğidir
    Görüldüğü üzere -p ve -n seçenekleri komut satırında tanımlı dosyaları okuyordu. -i seçeneği, -p ile kullanıldığında, dosyadan okuduğunu tekrar oraya yazma amacıyla kullanım işlevini sağlar (unix'deki sed gibi dosyayı edit etme işlevi).
    $ perl -p -i -e "s/fgh/xwz/g;" dosya1 dosya2 dosya3

    komutu ile dosyalardaki fgh yerine xwz konulur.
    -a : Satırı kelimelere ayırarak listeye (dizi)dönüştürme seçeneğidir. Bu seçenek -n veya -p ile kullanılır ve satırı otomatikman kelimelere ayırır (white space karakteri olmayan). Bu kelimeler @F sistem dizi değişkeninde saklanırlar. -a seçeneği satırda istenenleri çekip çıkarmada çok yararlıdır. Örneğin programa girişi yapılan satır Bu bir deneme kaydıdır ise @F sistem dizi değişkeninin içeriği şu şekildedir:
    ("Bu", "bir", "deneme", "kaydıdır")

    Mesela; Okunacak dosya adı datadosya ve kayıt formu şöyle olsun.
    Ad No Toplam

    girilmiş kayıtlar ise,
    Bertan TURK 103 474.32

    ertan NAR 10 57.32

    nur TABAK 1023 4700.32

    -n ve -a kullanılarak dosyadan No ve Toplam alanlarını cekip çıkaran ve yazdıran bir program örneği;
    yaz_toplam.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    while ($F[0] =~ /[^\d.]/) {

    shift (@F);

    next if (!defined($F[0]));

    }

    print ("$F[0] $F[1]\n");
    bu programın adı prog.pl olsun
    /usr/local/bin/perl -a -n prog.pl datadosya ¿

    103 474.32

    10 57.32

    1023 4700.32

    -F : (split) ayırma patterni tanımlama seçeneğidir. Kelimeleri ayırırken ayraç karakteri de koyar. -a ile birlikte kullanım için dizayn edilmiştir. Önceki programı aşağıdaki gibi çağrılmış olsun;
    /usr/local/bin/perl -a -n -F:: prog.pl datadosya ¿

    Bu durumda dosya okunurken kelime aralarına : : yerleştirilir.
    Bertan TURK:: 103::474.32 gibi...
    Normal split'de :: işaretleri // içine alınırdı. Burada bu karakterler olsada olur olmasada yani /::/ ile :: aynıdır.

    -0 : (O harfi değil, Sıfır'dır)Satır sonu girişini tanımlayan seçenektir. Şu ana kadar giriş satırlarını dosyadan veya klavyeden okuyorduk sonunda \n karakteri vardı. Biz istersek sondaki bu karakteri -0 seçeneği ile kendimiz belirliyebiliriz. Bu ASCII (8 tabanlı - octal) olarak belirlenebilir. Örneğin ; Boşluk karakterinin octal değeri 040 dır.
    Perl -0 040 prog.pl okunandosya ¿

    Komuyuyla prog.pl programı çağrılır onun okuma yaptığı okunandosya’nın satır sonu karakteri olarak boşluk karakteri kullanılması sağlanır. Konuyu iyice anlamak için diyelim ki data.txt dosyamız var ve içeriği de şöyle: (tabiiki satır sonlarında \n -satır sonu- karakteri var)
    Bu ilk satır

    ikinci satır

    ucuncu satır
    KaSSaS bunu beğendi.

  7. #7
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023

    Lightbulb


    Perl programımızın adı prog.pl ve içeriği de aşağıdaki kodlama olsun.
    prog.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl -0040

    while ($line = <>) {

    $line =~ s/\n//g;

    next if ($line eq "");

    print ("$line\n");

    }
    Calıştırdığımızda ekran dökümü aşağıdaki gibi olacaktır.
    $ prog.pl data.txt ¿

    Bu

    ilk

    satırikinci

    satırucuncu

    satır

    $

    - l (küçük -le- harfi) :Satır sonu çıktısı tanımlama seçeneğidir. Bu seçenek size belirlenen satır sonu karakterinin print fonksiyonu ile basılmasını sağlar. 0 gibi -l de octal değerle kullanılır(ASCII karakterin değeridir). Bu opsiyon tanımlanınca perl 2 şey yapar.
    1. Eğer -p veya -n opsiyonu tanımlıysa klavyeden girilen satırdaki son karakteri kaldırır.
    2. Print fonksiyonu çağrılınca –l ile tanımlanan karakter basılır.
    Örnek Program ; Bu program kelimeler arasına ascii kodu 197 .(Octal değeri 305 dir) olan karakteri basar. Program adı program.pl olsun.
    yaz_ascii_197.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl -l305

    print ("Merhaba");

    print ("Bu ikinci kelime");

    print ("Bu da 3. kelime");
    Çalışması : program.pl
    Merhaba Bu ikinci kelime Bu da 3. kelime
    -x : Bir mesajdan bir program çekip alma seçeneğidir. Örneğin bir file içeren elektronik mail mesajından programı almak gibi. -x opsiyonu tanımlıysa perl tüm satırları görmezlikten gelir taki başlık satırını görene kadar. Bunu anlaması, başta #! Karakterlerlerini görmesiyle olur. Eğer perl5 kullanıyorsak başlık satırı ayrıca perl kelimesini içermelidir. #! ve "perl" görülünce , aşağıdaki 3 şarttan biri gerçekleşinceye kadar proses devam eder.
    1. Program sonuna gelindiğinde,
    2. Ctrl+D veya Ctrl+Z karakterine gelindiğinde
    3. _ _END_ _ ifadesi içeren satıra gelindiğinde
    Örnek Program ;Bir program içinde perl program çalıştıran örnek. Program adı program.pl olsun.Komut satırından -x seçeneğiyle çalıştırılacak Aşağıdaki satırların tamamı program.pl satırlarının kodlarıdır
    end_prg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    ---------------------------------------------------------------------

    Bu program

    bir program içinde perl programi

    içerir

    program başlik açiklamasina kadarki satirlari

    dikkate almaz

    #!/usr/local/bin/perl

    print("Merhaba, Ben bir perl programiyim!\n");

    __END__
    yukardaki satır program sonunu ifade eder. bu satir da dikkate alinmaz..
    --------------------------------------------------------------------

    Çalışması :
    $ /usr/bin/perl -x program.pl

    Merhaba, Ben bir perl programiyim!

    Diğer Seçenekler
    · -u : core dump oluştur.
    · -S : Program PATH environment variable'da tanımlı DIR’da.
    · -D : Dahili debugger flag’larını ekle.
    · -T : Yazma güvenlik opsiyonu.
    · -d : Perl debugger kullan.
    Dosya Listesi
    · komutsatiri.pl
    · yaz_toplam.pl
    · prog.pl
    · yaz_ascii_197.pl
    · end_prg.pl
    Pattern (string / kelime ) Örneği BulmaPattern Matching)

    Giriş

    Bilhassa dosyalarda tarama yaparken çok kullanılan bu işlemin kurallarını öğreneceğiz.
    Pattern nedir ? : slash (/) karakterleri arasında bulunan karakter dizisidir.
    Ör: /gazi/ Bu pattern gazi kelimesini temsil eder. Pattern tarandığı bir satırda bulunduğunda uygun örnek bulunmuş olur. Biz şu ana kadar pattern bulma ile ilgili olarak @array = split(/ /, $line); benzeri örnekler gördük. Burada / / boşluk karakterini temsil ediyor ve o amaçla aranıyordu.
    Pattern bulmada kullanılan operatörler:

    Bir karakter stringinde pattern parçası bulmak için özel operatörler vardır. patternin varlığını test eden operatör =~ operatörüdür.Ör:
    $sonuc = $degisken =~ /abc/;
    Bu komutla $degisken içinde(stringte) abc patterninin bulunduğu test edilir. Sonuç $sonuç değişkenine atanır. Sonuç ise aşağıdakilerden biridir:
    1. 0 olmayan değer veya true (doğru) --- pattern stringte bulundu ise ---
    2.
    !~ operatorü, =~, operatörüne benzer tek farkla ki bu operatör patternin bulunmadığını (olumsuz karşılaştırma) test eder. Ör:
    $sonuc = $degisken !~ /abc/;
    Burada abc bulunmuşsa $sonuc değeri 0 dır.Bu tip kodlamalar özellikle şart ifadelerinde çok kullanılır. Örnek program : Program adı pat1.pl
    pat1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Icinde Lutfen kelimesi olan bir soru cümlesi giriniz:\n"); $soruyual = ; if ($soruyual =~ /lutfen/) { print ("Istenilen kelimeyi girdiniz.Teşekkür ederim!!\n"); } else { print ("Istenilen kelimeyi neden girmediniz?.\n"); }Çalışması:
    >pat1.pl Icinde Lutfen kelimesi olan bir soru cümlesi giriniz: Lutfen kapıyı açarmısınız? Istenilen kelimeyi girdiniz.Teşekkür ederim!>
    PATTERNLERDE ÖZEL KARAKTERLER

    + KARAKTERLERİ KULLANIMI

    önündeki(sol) karakterden 1 veya fazlası anlamındadır. ör: /de+f/ patterni aşağıdakilerinden herhangi birini bulur .
    def deef deeef deeeeeeef+ karakteri mumkun olduğunca önündeki karakterden 1 den fazla olanı bulur.

    Ör : /ab+/ ,abbc stringini taradığında, bulduğu örnek abb dir ab değil. + kullanımı özellikle bir satırı kelimelere bölme gibi işlemlerde çok kullanışlıdır. Örneğin bir satırda kelime aralarında bir veya birden fazla boşluk varsa ve bu boşluklardan kelime ayırımı yapacaksak + karakteri kullanımı çok uygundur.
    Ör : Girilen satırdaki kelimeleri sayan program yazalım. Satır girişi anında kelime aralarında 1 den fazla da boşluk bırakarak sonucu görelim. Program adı pat2.pl olsun.
    pat2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $kelimesayisi = 0; $satir = <STDIN>; while ($satir ne "") { chop ($satir); @kelimeler = split(/ +/, $satir); $kelimesayisi += @kelimeler; $satir = <STDIN>; } print ("Toplam kelime sayısı: $kelimesayisi\n");Çalışması:
    >pat2.pl Bu bir satır. Bu başka bir satır. Bu da son satır olsun. ^D Toplam kelime sayısı: 12>
    [] KARAKTERİ KULLANIMI

    Bu karakter bir alternatif gruptan bir karakteri tanımlamak için kullanılır. Ör: /d[aA]f/ patterni daf ve dAf örneklerini bulur. Bu kullanımda pattern içeriği daha fazla da olabilir. Ör:/a[0123456789]e/ gibi..
    Bu pattern a ile başlayan,onu takip eden bir rakam ve son karakter olarak e ile sonlanan örnekleri bulur. Daha evvel öğrendiğimiz + karakterini de [] karakteri ile birlikte kullanabiliriz. Ör: /a[cC]+f/ Bu pattern a ile başlayan,son karakteri f olan ve arada da bir veya birden fazla c ve C karakterleri olan örnekleri bulur.
    acf aCf accf aCcf aCcCcf
    Örnek Program : Adı pat3.pl. Önceki programda boşluk ve tab karakterini de düzenleyecek bir uygulama (kelimeler arsında bir veya fazla boşluk ve tab kullanılabilir).
    pat3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $kelimesayisi = 0; $satir = <STDIN>; while ($satir ne "") { chop ($satir); @kelimeler = split(/[\t ]+/, $satir); $kelimesayisi += @kelimeler; $satir = <STDIN>; } print ("Toplam kelime sayısı: $kelimesayisi\n");Çalışması:
    >pat3.pl Bu bir satır. Bu başka bir satır. Bu da son satır olsun. ^D Toplam kelime sayısı: 12>
    Bu örnekte bir öncekinden tek bir fark vardır split(/[\t ]+/, $satir); kodlaması. Bu kodlama ile $satir değişkeninde bulunan ekrandan girdiğimiz satırda eğer kelimeler arasında bir veya birden fazla boşluk veya tab varsa bunların tümünü kelime ayıraç karakteri say ve öyle değerlendir komutu vermiş oluyoruz.
    * KARAKTERİ KULLANIMI

    * karakteri önündeki karakterden bir veya fazla olduğunda veya hiç olmadığında geçerli örneği bulur. Örneğin, /de*f/ paterni aşağıdaki örnekleri elde eder
    df (ilk karakter -d-, son karakter -f-,arada -e- yok)def (ilk karakter -d-, son karakter -f-,arada 1 tane -e- var)deef (ilk karakter -d-, son karakter -f-,arada 1 den fazla -e- var) v.b...
    Bu karakter,[] karakteriylede kullanılır. Ör:/[eE]*/ gibi ..Bu pattern ile boş string ve e ile E karakterleri karışımı örnekler elde edilir.
    ? KARAKTERİ KULLANIMI

    ? karakteri önündeki karakterden bir tane veya hiç olmadığında geçerli örneği bulur. Örneğin patternimiz şu ise, /de?f/ bu patternin elde edeceği örnekler, df ve def tir.Dikkat ediniz deef,uygun örnek değildir çünkü, ? karakteri 1 taneden fazla karakteri kabul etmez.
    BU TİP ÖZEL KARAKTERLER İÇİN ESCAPE DİZİSİ KULLANIMI

    Perlde bulunan ve işlevi olan bazı karakterler ($,^,\, ..v.b.) pattern içinde nasıl kullanılır? Görelim. Bu karakterleri kendi özellikleriyle kullanmak için pattern içinde önlerine bir \ karakteri konur veya \Q \E karakterleri arasında kullanılır. mesela /\\+/ patterni stringte tüm \ karakteri (1 veya daha fazla) örneği olup olmadığını test eder. /\$/ $ karakterini, /\Q^ab*/ patterni, ^ab* karakterlerini, /\Q^ab\E*/ patterni ise,^a ile bunu takiben b karakterini test eder.(yani ^a dan sonra b olan ve b olmayanlar(* dan dolayı-hatırlayınız- doğru örneklerdir).
    HERHANGİBİR KARAKTER VE SAYI ÖRNEĞİ BULMA

    /a[0123456789]c/
    Bu pattern ilk karakteri a son karakteri c olan ve aralarındaki karakterde 0 ile 9 arası herhangi bir rakam olan örnekleri test eder.Bu pattern daha kısa olarak şöyle de yazılabilir;
    /a[0-9]c/
    aynı işlevi görürler. Örneğin a1c,a5c,a9c doğru örneklerdir. Benzer şekilde ( 0-9 kullanımı) küçük ve büyük harflerde test edilebilirler. Ör:
    /[a-z][A-Z]/, /[A-Z][A-Z]/, /[a-z][a-z]/, gibi..
    ve rakam ve harfler birarada da test edilebilirler. Ör:
    /[0-9a-zA-Z]/ gibi..([] arasındaki karakterlerden birisi varsa geçerlidir)
    Örnek program : Basit bir değişken adı sınama programı. Program adı pat4.pl olsun.
    pat4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Bir değişken adı giriniz:\n"); $degisken = <STDIN>; chop ($degisken); if ($degisken =~ /\$[A-Za-z][_0-9a-zA-Z]*/) # skalar değişken olması için # $ karakteri ile başlamalı,herhangi # bir harf ve _ karakteri veya # herhangibir harf veya rakam olmalı { print ("$degisken bir skalar değişkendir\n"); } elsif ($degisken =~ /@[A-Za-z][_0-9a-zA-Z]*/)# dizi değişkeni olması için # @ karakteri ile başlamalı,herhangi # bir harf ve _ karakteri veya # herhangibir harf veya rakam olmalı { print ("$degisken bir dizi değişkenidir\n"); } elsif ($degisken =~ /[A-Za-z][_0-9a-zA-Z]*/) # dosya değişkeni olması için # herhangi bir harf ile başlamalı, # sonra _ karakteri veya # herhangibir harf veya rakam olmalı { print ("$degisken bir dosya değişkenidir\n"); # Bu aşamada herhangibir değişken adı kuralına uymuyor demektir. } else { print (" $degisken değişken adı kurallarına uymuyor.\n"); }Çalışması :
    >pat4.pl Bir değişken adı giriniz: $soyad $soyad bir skalar değişkendir>
    TAM ÖRNEĞİ BULMA

    Yukardaki programda değişken adı olarak aşağıdakilerden
    $soyadad$soyad$soyad#atla
    sonuçta /\$[a-zA-Z][_0-9a-zA-Z]*/ patterni $soyad'ı bulacaktır. Dolayısıyla istediğimizin tam gerçekleşmemiş olur. Çünkü doğru örnek sadece 1.si ($soyad) olmalıydı.Tam olarak $soyad'ı bulsun istersek;yani sadece bu örnekte değil genelde tam örnek bulunsun istersek;tam örnek bulma (Pattern Anchoring) karakterleri kullanırız. Bunlar;
    · ^ veya \A, Sadece string başından bul.
    · $ veya \Z, Sadece string sonundan bul.
    · \b, Kelime sınırlarında(Kelimenin başı veya sonu) bul
    · \B Kelime içinde bul.
    karakterleridir.
    Şimdi örneklerle daha iyi anlayacağız.
    · /^def/ sadece stringin en baştan ilk 3 karakteri def olanı bul.
    · /def$/ sadece stringin en sondaki 3 karakteri def olanı bul.
    · /^def$/ sadece def stringini bul.
    Şimdi önceki programa (pat4.pl) daha iyi bir değişken adı test programı yazabiliriz.
    pat5.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    Program adı pat5.pl olsun. #!/usr/local/bin/perl print ("Bir değişken adı giriniz:\n"); $degisken = <STDIN>; chop ($degisken); if ($degisken =~ /^\$[A-Za-z][_0-9a-zA-Z]*$/) { print ("$degisken bir skalar değişkendir\n"); } elsif ($degisken =~ /^@[A-Za-z][_0-9a-zA-Z]*$/) { print ("$degisken bir dizi değişkenidir\n"); } elsif ($degisken =~ /^[A-Za-z][_0-9a-zA-Z]*$/) { print ("$degisken bir dosya değişkenidir\n"); } else { print ("$degisken değişken adı kurallarına uymuyor.\n"); }Çalışması:
    >pat5.pl Bir değişken adı giriniz: 5$soyad 5$soyad değişken adı kurallarına uymuyor.>
    KELİME SINIRLARINDA (kelimenin başında veya sonunda) TAM ÖRNEK BULMA: \b

    Örnek: Kelimenin başında :/\bert/ ert örneğiyle başlayan kelimeleri bulur. Örneğin ert,ertan gibi kelimeleri bulur bertan bulunmaz. Kelimenin sonunda :/ert\b/ kelimenin sonunda ert örneği olanları bulur. Örneğin ert,mert kelimeleri bulunur ertan,bertan bulunmaz. Şu örnekte ise sadece ert kelimesi bulunur. /\bdef\b/
    Pekala şöyle bir soru aklımıza gelebilir. kelimemiz $ertan olsaydı ,/\bert/ patterni ile bu ert kelimesi bulunurmuydu? -Evet. Çünki Enbaştaki $ karakteri stringin değişken olduğunu belirten karakter olup dikkate alınmazdı.
    KELİME İÇİNDE TAM ÖRNEK BULMA: \B

    Bunu anlamak için yine örneklere bakalım. /\Btan/ patterni, bulacağı örnek mesela ertan dır. tan kelimesinde test olumsuzdur. Benzer şekilde /tan\B/ patterninde taner kelimesi aranan örneğe uyar ve /\Btan\B/ pattern ine uyan örnekler mesela utanan,dartanyan olup. tan,ertan,taner uymaz. Bu karakterler (\b,\B) bize, bir kayıt(satır)dan ,split komutunu kullanmaksızın kelime arama imkanını, sağlar.
    Örnek Program : Bu kelimesini içeren satırların sayısını veren program.pat6.pl
    pat6.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl $sayi = 0; print ("Satırları Giriniz !:\n"); $satir = <STDIN>; while ($satir ne "") { if ($satir =~ /\bBu\b/) { $sayi += 1; } $satir = <STDIN>; } print ("'Bu' kelimesi içeren satir adeti: $sayi\n");Çalışması :
    >pat6.pl Satırları Giriniz !: Bu birinci satır. Bu ikinci satır. Bu üçüncü satır. Sondan önceki satır Son satır. ^D 'Bu' kelimesi içeren satir adeti: 3>
    Bu örnekte bir satırda kaç adet Bu kelimesi olduğunu düşünmedik. Sadece Bu kelimesi var mı şeklinde test ettik.Bir satırda birden fazla Bu kelimesi geçiyor ve biz kaç adet Bu geçtiğini bulmak istersek şu şekilde kodlama yapabiliriz.
    if ($satir =~ /\bBu\b/) { @kelimeler_dizisi = split(/[\t ]+/, $satir); $say = 1; while ($say <= @kelimeler_dizisi) { if ($kelimeler_dizisi[$say-1] eq "Bu") { $adet += 1; # kac adet Bu olduğu burada tutulur. } $say++; } }
    veya daha kısa olarak şöyle de kodlayabiliriz.
    if ($satir =~ /\bBu\b/) { @kelimeler_dizisi = split(/\bBu\b/, $satir); $adet += @kelimeler_dizisi - 1;}
    Hatta if kullanımına hiç gerek yoktur.
    @kelimeler_dizisi = split(/\bBu\b/, $satir); $adet += @kelimeler_dizisi - 1;
    kodlaması yeterlidir. Çünkü satır otomatikman aranacaktır ve varsa Bu kelimesi yeni bir kelimeyi (dolayısıyla yeni bir dizi elemanını)başlatan ayraç olacaktır. Dolayısıyla diziler 0.elemandan başladığından dizi boyutunun 1 eksiği bulunan kelime adedini verecektir.
    Pattern leri bir değişken içinde saklayarak,testlerde bu değişkenleri de kullanabiliriz.
    $pattern = "[\\t ]+"; @kelimeler_dizisi = split(/$pattern/, $satir); .. gibi.
    Örnek Program : Program Adı pat7.pl.İki dosyamız olsun. Kullanacağımız dosyaların adları bilgi.dat ve alan.dat olup içeriği ise,
    Bu ilk kayıttır.İkinci kayit.Dosyadaki son kayit.
    şeklinde olsun. Bu dosyaların adlarını komutsatırından girip,bir string 'i(pattern) bu dosyalarda taratalım.Taranacak string "kayit" olsun. Program stringi bulduğu takdirde hangi dosyada ve hangi kayıtta (satırda) olduğunu ekrana bassın.
    pat7.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl print ("Aranacak kelimeyi giriniz : "); $aranankelime = <STDIN>; chop ($aranankelime); $dosya_adi = $ARGV[0]; $satirno = $bulunansayisi = 0; while ($satir = <>) { $satirno += 1; if ($satir =~ /$aranankelime/) { print ("$dosya_adi, satir $satirno\n"); @kelimeler = split(/$aranankelime/, $satir); $bulunansayisi += @kelimeler - 1; } if (eof) { $satirno = 0; $dosya_adi = $ARGV[0]; } } if ($bulunansayisi == 0) { print ("String bulunamadı !!! \n"); } else { print ("Bulunan $aranankelime kelimesi sayısı: $bulunansayisi\n"); }Çalışması:
    >pat7.pl alan.dat bilgi.dat Aranacak kelimeyi giriniz : kayit alan.dat, satir 2 alan.dat, satir 3 bilgi.dat, satir 2 bilgi.dat, satir 3 Bulunan kayit kelimesi sayısı: 4>
    Dosya Listesi

    · pat1.pl
    · pat2.pl
    · pat3.pl
    · pat4.pl
    · pat5.pl
    · pat6.pl
    · pat7.pl

    REFERANSLAR

    Giriş
    Referans herhangi bir diziye, değişkene, altprograma işaret koymaktır denilebilir. Bir referans, bir değer için adrestir. Referanslar karışık data yapıları oluşturmada çok faydalıdırlar. Karışık data yapılarını gerçekte referanssız tanımlayamazsınız.
    Perl5 hard ve sembolik referanslar sunar. Bir sembolik referans; değişken adını içerir. Sembolik referanslar değişken adı yaratmak ve onları çalışma anında adreslemek için çok yararlıdırlar. Temel olarak sembolik bir referans bir file adına benzer veya UNIX’ deki soft link gibidir. Hard referans ise hard linkler gibidirler. Sadece aynı yere bir başka yoldur. Hard referanslar referans sayısını izler bu sayı 0 olunca başvurulan yeri serbest bırakır.
    Referansları Kullanma :
    Bir skalar değer bir değişkene başvursun. $gosterge. Herhangi bir skalar bir hard referans tutabilir. Çünkü diziler hash'lar(bileşik diziler) skalar içerirler . Bunları dikkate alarak kompleks yapılar inşa edilebilir.
    $gosterge'nin değerini, bir diziye gösterge olarak kullanmak için dizi içindeki maddeye başvurulur. Şu notasyonla : @$gosterge. Bu kullanım kabaca, $gosterge nin adresini alır ve onu bir dizi olarak kullanır şeklinde anlaşılabilir. Benzer şekilde hash’lar (Bileşik Dizi) için %$gosterge gösterimini kullanırız. Bu durum hash'ın ilk elemanına işaret koyarız anlamındadır
    Backslash (\) Operatörü Kullanımı :
    Bir operatörün adresini geçirmek için kullanılır. Genelde değişkene ikinci bir yeni referans yaratma amacıyla kullanılır.
    $degisken = 10;

    $gosterge = \$degisken;

    Burada; $gosterge, $degisken in değerini (10) içeren yere işaret koyar(referans verir). $degisken içindeki değeri $gostergeden alabilirsiniz hatta $degisken yok olsa dahi. Burada çalışan hard referanstır. $gosterge değişkeni , $degisken'in adresini içerir onun değerini değil.Değere erişmek için iki adet $ ile refere($$gosterge ) edilir. Örnek :
    referance1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl

    $deger = "ertan";

    $gosterge = \$deger;

    printf "'\$deger' degiskeninin içindeki değer $deger olup, gösterge adresi: $gosterge\n";

    printf "$gosterge memory adresindeki değer: $$gosterge\n";
    Çalışması ;
    $deger' degiskeninin içindeki değer ertan olup, gösterge adresi: SCALAR(0x80c1288)

    SCALAR(0x80c1288) memory adresindeki değer: ertan

    Referans ve Diziler :
    Perl konusunda belki en önemli nokta tüm @dizi ve %hash lar tek boyutludur ve skalar değer tutarlar ve direkt olarak dizi ve karmaşık data yapıları içermezler. Bir dizi elemanı sayı veya referans dır. Backslash operatörü ( \ ) ile skalar değişken gibi kullanılırlar. Örnek :
    referance2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl

    $gosterge = \@ARGV;

    printf "\n ARGV nin gösterge(pointer) Adresi = $gosterge \n";

    $i = scalar(@$gosterge);

    printf "\n Argüman sayısı : $i \n";

    $i = 0;

    foreach (@$gosterge) {

    printf "$i : $$gosterge[$i++];\n";

    }
    Çalışması ;
    program.pl 1 2 3 4
    ARGV nin gösterge(pointer) Adresi = ARRAY(0x806c378)

    Argüman sayısı: 4

    0 : 1;

    1 : 2;

    2 : 3;

    3 : 4;

    Çalışması ;
    Argüman sayısı: 0

    Programda, komut satırından girilen değerleri saklayan @ARGV dizisi elemanları içeriği basılır.
    2. satırda $gosterge referans olarak @ARGV’ye işaretlenmiştir(point). 3. satır ARGV’nin adresini basar. Siz genelde bu adresi kullanmazsınız ama başka bir diziyi kullanabilirsiniz. O dizinin ilk elemanına erişim için bu adrese ulaşmak kısa yoldur. $gosterge pointer'i dizinin ilk elemanının adresini döndürür. 74 satır scalar () fonksiyonu çağırır ve (skalar değişken tipi ile karıştırmayınız) Dizideki eleman sayısına erişir. @ARGV'ye parametreler geçirilmiştir ama scalar() tarafından istenen $gosterge pointerinin tipini tanımlamak gerekir. Bu sebepten @$pointer kullanarak bir dizi olarak parametre tipi tanımlanır. Bu durumda $gosterge tipi dizi için bir pointerdir. @$pointer in ilk elemanıın adresi bu durumda $pointer ile elde edilmiş olur. Onun eleman sayıları scalar () ile döndürülür.
    Bileşik dizilerde (hash) de \ operatörü kullanılabilir.Aşağıdaki örnekte Bileşik dizilerde kullanımı görelim. Örnek :
    Çalışması ; program.pl
    Aylar Bileşik dizisinin adresi = HASH(0x80c1294)

    01. Ay = Ocak

    02. Ay = Subat

    03. Ay = Mart

    04. Ay = Nisan

    05. Ay = Mayis

    06. Ay = Haziran

    07. Ay = Temmuz

    08. Ay = Agustos

    09. Ay = Eylul

    10. Ay = Ekim

    11. Ay = Kasim

    12. Ay = Aralik

    ÇOK BOYUTLU DİZİLERDE REFERANS :
    Kare, köşeli parantez kullanılır. Genel formatı;
    $diziReferans->[$indeks] ........tek boyutlu dizi

    $diziReferans->[$indeks1][$indeks2] ........iki boyutlu dizi

    $diziReferans->[$indeks1][$indeks2][$indeks3] ........üç boyutlu dizi

    şeklindedir. Örnek :
    referance4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    Çalışması ; program.pl
    $tablo ->[0] = Siyah

    $tablo ->[1] = Beyaz

    $tablo ->[2][0] = Kartal

    $tablo ->[2][1] = 2000

    $tablo ->[2][2] = YILI

    $tablo ->[3][0] = ŞAMPİYONU

    $tablo ->[3][1] = Puan

    $tablo ->[3][2] = 100

    ALT YORDAMLARA REFERANS :
    dir skalar veya dizinin bir maddesine referansla aynı tarzdadır. Aşağıdaki tipte ifade edilir.
    $alt_prog_gosterge = sub {alt yordam bildirimleri} ;
    referans tarafından alt yordam çağırmak için aşağıdaki tipte referans kullanmalısınız.
    &$alt_prog_gosterge( parametreler);

    Örnek :
    Çalışması ; program.pl
    2 4
    2
    5 6
    5

    Çok Boyutlu Dizilerle, Çalışmak İçin, Altyordam Kullanımı :
    Örnek :
    referance6.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/bin/perl

    @isimler = (Ahmet,Bertan,Ertan);

    @telefonlar = (2126840,2126841,2126842);

    $say = 0;

    &aktar_yazdir(\@isimler, \@telefonlar);

    sub aktar_yazdir{

    my ($ad,$tel) = @_;

    foreach (@$ad) {

    print "ad[$say] = " . @$ad[$say] . " " . "\ttel[$say] = ". @$tel[$say] ."\n";

    $say++;

    }

    }
    Çalışması: program.pl
    ad[0] = Ahmet tel[0] = 2126840

    ad[1] = Bertan tel[1] = 2126841

    ad[2] = Ertan tel[2] = 2126842


    Değişkenlerde alias kullanımı
    Aşağıdaki tanımı inceleyelim.
    sub altprogram1 {

    local (*altdizi) = @_;

    $dizi_uzunlugu = @altdizi;

    }

    altprogram1 içindeki *altdizi tanımı perl' e der ki: Gerçek liste üzerinde işlem yapmak yerine kopya yap. Bu altyordam, &altprogram1(*altdizi2); gibi bir ifadeyle çağırılınca perl, altdizi ile altdizi2'nin aynı dizi değişkene başvurmasını gerçekleştirir. Bir isim alias olarak verildiğinde, o ismi taşıyan tüm değişkenler alias kullanarak başvurmuş olurlar. Bu demektir ki,bu örnekte @altdizi ve @altdizi2 aynı diziye başvururlar. Şu iki ifade,
    altprogram1(*altdizi);

    local (*altdizi2) = @_;

    şu ifadeye eşittir;
    local (*altdizi2) = *altdizi;

    her bir durumda, altdizi isminin alias' ı olarak altdizi2 tanımlanmıştır. Çünkü altprogram içindeki local tanımı *altdizi2 içerir ve altdizi2 ve altdizi sadece altprogram çalıştığında eşittir. Bir isim için şöyle bir alias tanımlarsak;
    *altdizi2 = *altdizi;

    ve bu ifade ana programın bir bölümünde ise, altdizi2, altprogramlar dahil tüm programda altdizi için bir alias olur. $altdizi2, @altdizi2 ve %altdizi2 (eğer tanımlıysa) değerleri kaybolur. Örnek programa bakalım:
    referance7.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

    #!/usr/local/bin/perl

    *name2 = *name1;

    $name1 = 14;

    print ("$name2\n");
    çalıştır
    14
    alias kullanımı karışık olduğundan kesin emin olmadıkça kullanılmamalıdır onun yerine değişken adını bir stringe koyup eval ile çalıştırmak tercih edilebilir. Örneğin;
    $isim2 = '$isim1';

    eval ("$isim2 = 14;"); # $isim1 içeriği 14 ' dür.

    Dosya Listesi
    · referance1.pl
    · referance2.pl
    · referance4.pl
    · referance6.pl
    · referance7.pl
    -bitti-
    godoro.com dan yararlanılmıştır.
    KaSSaS ve Fate_ bunu beğendi.

  8. #8
    Ehil Üye zeet06 - ait Kullanıcı Resmi (Avatar)
    Üyelik tarihi
    Jul 2008
    Mesajlar
    1.023
    "O zaman vecd ile bin secde eder -varsa- taşım."
    -Vücuda verilen kuvvet, Hak’ka ibadet, halka hizmet içindir.

+ Konu Cevaplama Paneli

Konu Bilgileri

Users Browsing this Thread

Şu an 1 kullanıcı var. (0 üye ve 1 konuk)

     

Benzer Konular

  1. Ruby Programlama
    By zeet06 in forum Bilgisayar ve İnternet Sorunları
    Cevaplar: 1
    Son Mesaj: 16.01.09, 16:26
  2. C Programlama
    By zeet06 in forum Bilişim Haberleri ve Bilimsel Makaleler
    Cevaplar: 13
    Son Mesaj: 14.01.09, 14:59
  3. Python Programlama
    By zeet06 in forum Bilgisayar ve İnternet Sorunları
    Cevaplar: 3
    Son Mesaj: 14.01.09, 13:47
  4. C++ Programlama
    By zeet06 in forum Bilgisayar ve İnternet Sorunları
    Cevaplar: 4
    Son Mesaj: 28.11.08, 15:12
  5. Pascal ile Programlama
    By zeet06 in forum Bilgisayar ve İnternet Sorunları
    Cevaplar: 1
    Son Mesaj: 06.11.08, 21:02

Bu Konudaki Etiketler

Yetkileriniz

  • Konu Acma Yetkiniz Yok
  • Cevap Yazma Yetkiniz Yok
  • Eklenti Yükleme Yetkiniz Yok
  • Mesajınızı Değiştirme Yetkiniz Yok
Yemek Tarifleri ListeNur.de - islami siteler listesi
Google Grupları
RisaleForum grubuna abone ol
E-posta:
Bu grubu ziyaret et

Search Engine Friendly URLs by vBSEO 3.6.0