Önce bir uyarı: byLine satırları hep aynı ara belleğe okur. Dolayısıyla, satırın içindeki bir veriyi elinde tutmak istiyorsan, örneğin 'saklanan = satır[x..y]' yapamazsın çünkü bir sonraki satır okununca aynı yerin üstüne yazılabilir. O yüzden, kopyalaman gerekir: 'saklanan = satır[x..y].idup' (veya duruma göre '.dup').

Başka yöntem, byLine değil, byLineCopy kullanmaktır. Bu, her satırı yeni belleğe okur. Hangi yöntemin daha iyi olduğuna duruma göre karar verilebilir. Örneğin, byLineCopy bütün satırı tek kere kopyalar ve sen mutlu mutlu 'saklanan = satır[x..y]' yapabilirsin.

formattedRead, formattedWrite'ın yazabildiği çoğu şeyi (herşeyi?) okumalı:

import std.stdio;
import std.format;

void main() {
   string[] dizi;
   string satir = `[ "abc", "xyz" ]`;
   formattedRead(satir, "%s", &dizi);
   writeln(dizi);
}

Başka yöntemler de var: splitter, regex, vs.

(Bunu zaten sonradan düzeltmişsin.) elemanlar dizisiyle ilgili hata bariz. :) elemanlar'a hiç eleman eklemeden ilk elemanına erişmeye çalışıyorsun. Şöyle olabilir:

   elemanlar ~= Eleman("ahmet");    // Artık elemanı var

Ama bazen böyle döngüyle uğraşmak yerine zincirleme çağrılar öneriliyor:

import std.algorithm : findSplit;
import std.range.primitives : isInputRange;
import std.algorithm : map, filter, each, splitter;
import std.stdio : writefln;
import std.array : array;

struct Eleman(Özellikler) if (isInputRange!Özellikler) {
   string isim;
   Özellikler özellikler;
}

// Yalnızca bir kolaylık işlevi; kodda eleman(a, b) diye oluşturabiliyoruz
auto eleman(Özellikler)(string isim, Özellikler özellikler) {
   return Eleman!Özellikler(isim, özellikler);
}

void main() {
   auto satırlar = [ "h2:class id", "span:", "img:class id src", "istenmeyen: foo" ];

   auto elemanlar = satırlar
                    .map!(satır => satır.findSplit(":"))  // çokuzlu döndürür; ç diyorum:
                    .filter!(ç => ç[0] != "istenmeyen")
                    .map!(ç => eleman(ç[0], ç[2].splitter));

   // Şimdi 'elemanlar' tembelce oluşturulan bir aralıktır
   writefln("Okunan elemanlar: %s", elemanlar);

   // Ama istersek örneğin hepsinden oluşan bir dizi oluşturabiliriz:
   auto dizi = elemanlar.array;

   writefln("Oluşturulan dizi: %-(%s, %)", dizi);
}

Duruma göre bu çok daha iyi olabiliyor çünkü bu örnekte örneğin bütün elemanları writefln ile yazdırabildiğimiz halde hiçbirisi için yer ayırmak zorunda kalmadık. Milyonlarca eleman olduğunda az bellek kullandırdığından bu yöntem daha hızlıdır.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

O satırda isim eksik. Şu oluyor:

   string satir = `"erdem": [ "h2:class id", "span:" ]`;

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali bey teşekkürler! :)

Gerçi eleman yapısının parametrelerini dizge olarak değiştirdim. Ama gene de formattedRead ile dizilerin de okunabildiğini öğrenmem iyi oldu.

Yazım biçimini biraz değiştirdim. Şimdi yazım biçimlerini ayırt eden kısım üzerinde çalışıyorum.

'h2:class id
span:
td:class=.1
img:class=manzara'

Örneğin 'span:' tamamen bir etiketi siliyor. '' ya da 'yazı ' --> yazı oluyor.

'h2:class id' ise h2 etiketinin class ve id özellikleri siliyor. Etiket ve varsa diğer özellikler duruyor.

'td:class=.1' ise sadece ilk özelliğin değerini siliyor. '' ilk özellik değeri silindikten sonra '' oluyor.

'img:class=manzara' ise nasip olursa sadece sınıfı manzara olan özelliği silecek.

struct Eleman
{
   this(string isim, string özellikler, string eski = "")
   {
       this.isim = isim;
       this.özellikler = özellikler.split();
       this.eski = eski;
       if (this.özellikler.length == 1 && indexOf(dizgeYap(this.özellikler), "=") > 0)
           if (indexOf(dizgeYap(this.özellikler), ".") > 0)
               ilkDeğeriSil_ = true;
           else
               özellikSil_ = true;
   }

   string isim;
   string[] özellikler;
   string eski;

   bool ilkDeğeriSil_ = false;
   bool özellikSil_ = false;

   bool ilkiSil () const @property
   {
       return ilkDeğeriSil_;
   }
   bool özellikSil () const @property
   {
       return özellikSil_;
   }
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Adresleri okuyan bir yapı üzerinde çalışıyorum.

struct Adres
{
   import std.string;
   import std.algorithm;
   import std.stdio;

   private
   {
       string sunucu_;
       string adres_;
       string kök_;
       string kütük_;
       string[] dizinler_;
       string iletişimKuralı_;
   }

   this (string adres, int derinlik = 0)
   {
       adres_ = adres;
       auto işlenen = adresİşle(adres, derinlik);

       if (!işlenen)
       {
           throw new Exception("Adresi işleyemiyorum" ~ adres_);
       }

   }

   bool adresİşle(string adres, int derinlik)
   {
       auto i = adres.findSplit("://");
       string kalan;
       if (i[1].length)
       {
           iletişimKuralı_ = i[0].toLower;
           kalan = i[2];
       }
       else
       {
           return false;
       }

       string kök;

       sunucu_ = kalan.findSplit("/")[0];


       for(int k = 0; k < derinlik + 1; ++k)
       {
           i = kalan.findSplit("/");
           kök ~=  i[0] ~ i[1];
           kök_ = "%s://%s".format(iletişimKuralı_, kök[0..$ - 1]);
           kalan = i[2];
       }

       auto dizinler = split(kalan, "/");

       for(int j = 0; j < dizinler.length - 1; ++j)
       {
           dizinler_ ~= dizinler[j];
       }

       kütük_ = dizinler[dizinler_.length];

       return true;
   }
}

unittest
{
   auto a = Adres("http://www.erdem.tk/wiki/html/arduino/arduinobaslangic.html", 3);
}

Böylelikle oluşturulacak dizinler arasında

   foreach(dizin; adres.dizinler)

şeklinde gezilebilir. Bunu da ddili'ni aktarmaya çalışırken farkettim. Örneğin benim sitem tek bir derinlik kullanıyor.

Ama

http://ddili.org/ders/d/index.html

şeklinde bir adresi işlerken ders -> d vs.. şeklinde diğer alt dizinleri de oluşturması gerekiyor.

Yerel dizinleri ya da uzak dizinleri oluştururken de böyle gezdiğimiz dizinleri takip eden bir yapı sizce faydalı olur mu.

void tekSayfaOluştur(Document belge)
{
   yerelDiziniOluştur();
   auto sayfaBaşlığı = belge["h1"][0].innerText;
   writeln(sayfaBaşlığı);
}

void yerelDiziniOluştur()
{
   adımAt("veri");
   adımAt("yerel");
}

void adımAt(string dizin)
{
   if (exists(dizin))
   {
       chdir(dizin);
   }
   else
   {
       mkdir(dizin);
       chdir(dizin);
   }
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

derinlik parametresine gerek olmamalı. Sanırım std.path modülü işine yarayabilir: baseName, dirName, ve arkadaşları... Gerekirse, mkdir'e ek olarak mkdirRecurse olduğunu da hatırlatırım.

Ufak bir basitleştirme:

void adımAt(string dizin)
{
   if (!exists(dizin))
   {
       mkdir(dizin);
   }
   chdir(dizin);
}

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (erdem:1481393981):

Ben tam olarak anlamadım. Web sayfalarını dolaşın bir bot mu yapmak istiyorsun yoksa web sayfası içeriğini yerele indiren bir uygulama mı?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Dokuwiki sayfalarından normal bir web sayfası oluşturan bir uygulamayı D diline aktarmaya çalışıyorum.

Siteyi böcüler, botlar vs.. sarmasın diye açık yazmıyorum ama erdem.tk adresine wiki/arduino/arduinobaslangic.html ekleyin. Orada bir dokuwiki sayfası var.

O sayfadan bootstrap şablonu kullanan bu web sayfasını otomatik oluşturuyor.

http://www.erdem.tk/arduino/arduino-başlangıç (http://www.erdem.tk/arduino/arduino-başlangıç)

Hatta bu ana bölümleri de:

http://www.erdem.tk/arduino/

İleriki aşamada kullanıcı wiki üzerinde değişiklik yaptığı zaman otomatik olarak sayfaları güncelleyecek şekilde bir program yazmaya çalışıyorum.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Şimdi anladım :-D Gayet başarılı görünüyor. Sanırım büyük bir kısmını tamamlamışsın, çevrilen sayfada gayet düzgün görünüyor.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Şu an site aslında tamamen işlevsel yani yayınlamak istediğimiz içeriğin tamamı yayınlanıyor ama tam otomatik değil.
Arka planda python programı çalışıyor. Hangi sayfaları yayınlamak istediğimizi de yayındakiler.html kütüğündeki sayfalar belirliyor. O da bir filtre oluşturuyor.

' NOCACHE

{{pagequery>@:arduino @:ubuntu @:dersler @:yunusemre @:yazilar @:kitap *;sort=ns,name;cols=1; filter=!name:(deneme|sekizled|neler|apache2)}}'

Buraya yayınlanmasını henüz istemediğim taslak halinde olan yazıları ekliyorum. Aslında daha iyisi belki her sayfaya yayınla gibi bir düğme eklenebilir ama bunun için dokuwiki eklentisi yazmak gerekiyor sanırım.

D programı henüz emekleme aşamasında! :-)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

ftp ile dosyaları karşıya yükleme kısmını ekledikten sonra D kodu kabaca bitti sayılır.

Göstermek için elle bir tane yükledim.

http://www.erdem.tk/eskiler/arduino

Kabaca diyorum çünkü eklenebilecek çok özellik var. Örneğin program site haritasını kendisi oluşturabilir, bir tane web örümceğine ihtiyacımız olabilir. Tüm bunların dışında programı görsel bir uygulamaya çevirmeyi düşünüyorum ki D ile GTKD kullanarak görsel bir uygulama yazmak benim için de bir ilk olacak.

Bu arada vibe.d ile yazılmış bir günlük dikkatimi çekti.

https://github.com/rejectedsoftware/vibelog

vibe.d'nin DIET şablonlarını kullandığını biliyoruz.

https://tour.dlang.org/tour/en/vibed/diet-templates

Benim merak ettiğim acaba normal html kütüklerini de şablon olarak kullanabiliyor muyuz. Böylelikle site içeriğini arsd.dom oluşturur diğer taraftan vibe.d'nin sunucu özelliklerinden faydalanabiliriz.

Bunu da şu şekilde örneklendirebiliriz. Ortamın sıcaklık nem bilgilerini ölçen bir Arduino uygulamamız var. Bunu sunucu tarafında yayınlamak istiyoruz. Normal site içeriği yanında işte bu tür bir uygulama için de vibe.d'nin özelliklerinden faydalanıyoruz. Umarım ben de doğru anlamışımdır. ;-)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]