diff options
Diffstat (limited to 'tr-tr')
| -rw-r--r-- | tr-tr/c++-tr.html.markdown | 1077 | ||||
| -rw-r--r-- | tr-tr/git-tr.html.markdown | 596 | ||||
| -rw-r--r-- | tr-tr/markdown-tr.html.markdown | 2 |
3 files changed, 1674 insertions, 1 deletions
diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown new file mode 100644 index 00000000..2c841456 --- /dev/null +++ b/tr-tr/c++-tr.html.markdown @@ -0,0 +1,1077 @@ +--- +language: c++ +lang: tr-tr +filename: learncpp-tr.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Connor Waters", "http://github.com/connorwaters"] + - ["Ankush Goyal", "http://github.com/ankushg07"] + - ["Jatin Dhankhar", "https://github.com/jatindhankhar"] + - ["Adem Budak", "https://github.com/p1v0t"] +--- + +C++ +[yaratıcısı Bjarne Stroustrup'a göre](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), + +- "daha iyi bir C" yapmak +- veri soyutlamayı desteklemek +- nesneye yönelik programlamayı deskteklemek +- tipten bağımsız programlamayı desteklemek + +için tasarlanmış bir sistem programlama dilir. + +Sözdizimi daha yeni dillerden daha zor veya karmaşık olsa da işlemcinin doğrudan çalıştırabileceği +native komutlara derlenerek, donanım üzerinde (C gibi) sıkı bir kontrol sağlar, bunu yaparken +tipten bağımsızlık, exception'lar ve sınıflar gibi yüksek-seviyeli özellikleri destekler. +Bu hız ve kullanışlılık C++'ı en çok kullanılan dillerden biri yapar. + +```c++ +////////////////////// +// C ile karşılaştırma +////////////////////// + +// C++ _neredeyse_ C'nin bir üstkümesidir, değişken tanımı, basit tipleri +// ve fonksiyonları için temelde aynı sözdizimini paylaşır. + +// Aynı C gibi, programın başlangıç noktası bir integer döndüren +// main fonksiyonudur. +// Bu değer programın bitiş statüsünü belli eder. +// Daha fazla bilgi için bknz http://en.wikipedia.org/wiki/Exit_status . + +int main(int argc, char** argv) +{ + // Komut satırı argümanları C'de olduğu gibi argv ve argc ile geçilir + // argc, argüman sayısını belli eder, + // argv, argümanları belli eden, C-stili string'lerin (char*) dizisidir. + // İlk argüman çağrılan programın adıdır. + // Eğer argümanları umursamıyorsan, argv ve argc kullanılmayabilir + // int main() gibi + + // 0 çıkış durumu başarıyı belirtir. + return 0; +} + +// Bunlara rağmen C++ aşağıdaki noktalarda farklılaşır: + +// C++'ta, karakterler char türündendir +sizeof('c') == sizeof(char) == 1 + +// C'de, karakterler int türündendir +sizeof('c') == sizeof(int) + + +// C++ katı bir prototip kuralına sahiptir +void func(); // fonksiyon argüman kabul etmez + +// C'de +void func(); // fonksiyon herhangi bir sayıda argüman kabul edebilir + +// C++'da NULL yerine nullptr kullanılır +int* ip = nullptr; + +// C standard başlıkları başına "c" eklenip, sondaki .h +// kullanılmadan C++'ta kullanılabilir +#include <cstdio> + +int main() +{ + printf("Hello, world!\n"); + return 0; +} + +////////////////////////////////// +// Fonksiyonun fazladan yüklenmesi +////////////////////////////////// + +// C++ herbir fonksiyonun farklı parametereler +// aldığı fonksiyon fazladan yüklenmesini desktekler + +void print(char const* myString) +{ + printf("String %s\n", myString); +} + +void print(int myInt) +{ + printf("My int is %d", myInt); +} + +int main() +{ + print("Hello"); // void print(const char*) fonksiyonunu çağırır. + print(15); // void print(int) fonksiyonunu çağırır. +} + +//////////////////////////////// +// Default fonksiyon argümanları +//////////////////////////////// + +// Eğer çağırıcı tarafından fonksiyona argüman sağlanmamışsa, +// fonksiyona default argüman verebilirsin + +void doSomethingWithInts(int a = 1, int b = 4) +{ + // Burada int'lerle birşeyler yap +} + +int main() +{ + doSomethingWithInts(); // a = 1, b = 4 + doSomethingWithInts(20); // a = 20, b = 4 + doSomethingWithInts(20, 5); // a = 20, b = 5 +} + +// Default argümanlar, argüman listesinin sonunda yer almalı. + +void invalidDeclaration(int a = 1, int b) // Hata! +{ +} + + +///////////////////////// +// Namespace(İsim uzayı) +///////////////////////// + +// Namespace'ler değişken, fonksiyon ve diğer bildirimlerin +// kapsama alanını ayırır. +// Namespace'ler içiçe geçebilir. + +namespace First { + namespace Nested { + void foo() + { + printf("This is First::Nested::foo\n"); + } + } // Nested namespace'inin sonu +} // First namespace'inin sonu + +namespace Second { + void foo() + { + printf("This is Second::foo\n"); + } +} + +void foo() +{ + printf("This is global foo\n"); +} + +int main() +{ + // Second namespace'i içinideki tüm sembolleri mevcut kapsama alanına dahil eder. + // Dikkat edersen artık yalnızca foo() çağrısı çalışmayacaktır çünkü hangi + // namespace'ten çağrıldığı açık değildir. + using namespace Second; + + Second::foo(); // "This is Second::foo" yazdırıır + First::Nested::foo(); // "This is First::Nested::foo" yazdırır + ::foo(); // "This is global foo" yazdırır. +} + +/////////////// +// Input/Output +/////////////// + +// C++'ta input ve output stream'leri kullanır. +// cin, cout ve cerr,sırasıyla, stdin, stdout, ve stderr'i temsil eder. +// << araya ekleme ve >> aradan çıkarma operatörüdür. + +#include <iostream> // I/O stream'lerini dahil etmek için + +using namespace std; // Streamler std namespace'i içindedir(standard kütüphane) + +int main() +{ + int myInt; + + // stdout (veya terminal/screen)'ta çıktı verir + cout << "Enter your favorite number:\n"; + // Girdiyi alır + cin >> myInt; + + // cout ayrıca formatlanabilir + cout << "Your favorite number is " << myInt << "\n"; + // prints "Your favorite number is <myInt>" + + cerr << "Used for error messages"; +} + +////////////// +// String'ler +///////////// + +// String'ler C++'ta nesnedir ve pek çok üye fonksiyonu vardır +#include <string> + +using namespace std; // String'ler de std namespace'i içindedir. (standard kütüphane) + +string myString = "Hello"; +string myOtherString = " World"; + +// + eklemek için kullanıldır +cout << myString + myOtherString; // "Hello World" + +cout << myString + " You"; // "Hello You" + +// C++'ta stringler are mutable'dır (değişebilir). +myString.append(" Dog"); +cout << myString; // "Hello Dog" + + +/////////////////////// +// Reference (Referans) +/////////////////////// + +// C'deki pointer'lara ek olarak +// C++ _reference_'lara sahiptir. +// Bunlar bir kere atandınğında tekrardan atanamayan pointer'dır +// ve null olamaz. +// Değişkenin kendisiyle aynı sözdizimine sahiptir: +// Değerine ulaşmak için * ihtiyaç yoktur ve +// atama için & (address of) kullanılmaz. + +using namespace std; + +string foo = "I am foo"; +string bar = "I am bar"; + + +string& fooRef = foo; // Bu foo'nun reference'ını oluşturur. +fooRef += ". Hi!"; // foo'yu reference'ı üzerinden değiştirir. +cout << fooRef; // "I am foo. Hi!" yazdırır. + +// "fooRef"e yeniden atama yapmaz. Bu "foo = bar" denktir ve bu satırdan sonra +// foo == "I am bar" olur +cout << &fooRef << endl; // foo'un adresini yazdırır +fooRef = bar; +cout << &fooRef << endl; //Hala foo'nun adresini yazdırır +cout << fooRef; //"I am bar" yazdırır + +// fooRef'in adresi aynı kalır yani hala foo'nun adresidir. + +const string& barRef = bar; // bar'a const reference oluşturur +// C'de olduğu gibi, const değerler (pointer'lar ve reference'ler) değiştirilemez. +barRef += ". Hi!"; // Hata, const reference'ler değiştirilemez. + +// Kısa bir ekleme: reference'lere devam etmeden önce, geçici nesne konseptinden +// bahsetmeliyiz. Mesela aşadaki gibi bir kod var: +string tempObjectFun() { ... } +string retVal = tempObjectFun(); + +// Bu iki satırda aslında ne oluyor: +// - tempObjectFun fonksiyonundan bir string nesnesi dönüyor +// - dönmüş olan nesneyle yeni bir string oluşturuyor +// - dönmüş olan nesne yok ediliyor +// İşte bu dönen nesneye geçici nesne denir. Geçici nesneler fonksiyon nesne +// döndürdüğünde oluşturulur ve ifade işini bitirdiğinde yok edilir (Aslında, +// standard'ın söylediği şey bu ama derleyiciler bu davranışı değiştirmemize +// izin veriyor. Daha fazla detay için "return value optimization" diye +// aratabilirsin. Sonuç olarak aşağıdaki kodda: +foo(bar(tempObjectFun())) + +// foo ve bar'ın varolduğunu kabul ediyoruz, tempObjectFun'dan dönen nesne +// bar'a geçti ve foo çağrılmadan önce yokedildir. + +// Şimdi reference'lara dönelim. "ifadenin sonunda" kuralının bir istisnası +// eğer geçici nesne const reference'a geçildiyse oratya çıkar, bu durumda +// nesnenin ömrü mevcut kapsama alanına kadar uzar: + +void constReferenceTempObjectFun() { + // constRef geçici nesneyi alır ve bu durum fonksiyonun sonuna kadar geçerlidir. + const string& constRef = tempObjectFun(); + ... +} + +// C++11 ile gelen diğer bir reference geçici nesnelere özeldir. Bu türden birden +// bir tip tanımlayamazsın ama aşırı yüklenme sırasında bu tipler öncelik alır: +void someFun(string& s) { ... } // Regular reference +void someFun(string&& s) { ... } // Geçici nesneye reference + +string foo; +someFun(foo); // regular reference'ı çağırır +someFun(tempObjectFun()); // geçici reference'ı çağırır + +///////////////////// +// Enum +///////////////////// + +// Enum'lar sabit değerler yapmak için kullanılır ve çoğunlukla kodun daha okunaklı +// olması için kullanılır + +enum ECarTypes +{ + Sedan, + Hatchback, + SUV, + Wagon +}; + +ECarTypes GetPreferredCarType() +{ + return ECarTypes::Hatchback; +} + +// C++11 ile beraber bir tipi enum'a atamanın kolay bir yolu var, bu enum'un istenen +// tipe dönüştürmek için kullanışlı bir yöntem +enum ECarTypes : uint8_t +{ + Sedan, // 0 + Hatchback, // 1 + SUV = 254, // 254 + Hybrid // 255 +}; + +void WriteByteToFile(uint8_t InputValue) +{ + // Serialize the InputValue to a file +} + +void WritePreferredCarTypeToFile(ECarTypes InputCarType) +{ + // enum uint8_t tipine dönüştürüldü + WriteByteToFile(InputCarType); +} + +// Diğer yandan enum'ların yanlışlıkla integer tipini veya diğer enumlara dönüşmesini +// istemiyorsan enum class olarak tanımlayabilirsin +enum class ECarTypes : uint8_t +{ + Sedan, // 0 + Hatchback, // 1 + SUV = 254, // 254 + Hybrid // 255 +}; + +void WriteByteToFile(uint8_t InputValue) +{ + // Serialize the InputValue to a file +} + +void WritePreferredCarTypeToFile(ECarTypes InputCarType) +{ + // ECarTypes, uint8_t tipinde olmasına rağmen, "enum class" olarak + // tanımlandığından derlenmeyecektir! + WriteByteToFile(InputCarType); +} + +/////////////////////////////////////////// +// Sınıflar ve nesneye yönelik proglamalama +/////////////////////////////////////////// + +// Sınıflara(class) ilk örnek +#include <iostream> + +// Sınıfı tanımla. +// Sınıflar genelde header (.h veya .hpp) dosyalarında tanımlanır. +class Dog { + // Üye değişkenler ve fonksiyonlar default olarak private'dir. + std::string name; + int weight; + +// Aşağıda, "private:" veya "protected:" bulunana kadar +// bütün üyeler public'tir. +public: + + // Default constructor + Dog(); + + // Üye fonksiyon bildirimi (gerçeklenimi aşağıda) + // Dikkat ederseniz using namespace std; yerine + // std::string kullandık. + // Hiçbir zaman header dosyasında "using namespace std;" kullanma. + void setName(const std::string& dogsName); + + void setWeight(int dogsWeight); + + // Nesnenin durumunu değiştirmeyen fonksiyonlar const ile işaretlenmelidir + + // Türetilen sınıflarda fonksiyonu override edebilmek için başına + // _virtual_ eklenmelidir. + // Fonksiyonlar, performanslar ilgili nedenlerden ötürü default olarak virtual değildir + virtual void print() const; + + // Fonksiyonlar class içinde de tanımlanabilir. + // Bu şekille tanımlanan fonksiyonlar otomatik olarak inline olur. + void bark() const { std::cout << name << " barks!\n"; } + + // C++ constructor'ların yanında destructor'da sağlar. + // Bunlar nesne silindiğinde veya scope'un dışına çıktığında çağrılır. + // Bu RAII gibi güçlü paradigmaları etkin kılar. + // (aşağıda açıklandı) + // Eğer sınıf kendisinden türetiliyorsa, destructor virtual olmalıdır, + // eğer virtual değilse, türetilmiş sınıfın destructor'ı nesne, ana sınıf + // referans'ı veya pointer'ı üzerinden yok edildiğinde, çağrılmayacaktır. + virtual ~Dog(); + +}; // class tanımının sonuda noktalı virgül(;) olmalıdır. + +// Sınıfın üye fonksiyonları genelde .cpp dosyaları içinde gerçeklenir. +Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objects (such as strings) should be passed by reference +// Nesneler (string gibi) reference ile fonksiyonlara geçilmelidir +// Eğer nesneleri değiştirilecekse reference ile fonksiyonlara geçilmelidir, +// değiştirilmeyecekse const reference ile geçilmelidir. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Dikkat edersen "virtual" yalnızca bildirimde gerekli, tanımlamada değil. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +Dog::~Dog() +{ + std::cout << "Goodbye " << name << "\n"; +} + +int main() { + Dog myDog; // "A dog has been constructed" yazdırır + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.print(); // "Dog is Barkley and weighs 10 kg" yazdırır. + return 0; +} // "Goodbye Barkley" yazdırır. + +// Inheritance(Miras) + +// Bu sınıf, Dog sınıfında public ve protected olan herşeyi miras alır, +// private olanları da miras alır ama, public ve protected sınıflar aracılıyla +// yapılmıyorsa, doğrudan erişemez. +class OwnedDog : public Dog { + +public: + void setOwner(const std::string& dogsOwner); + + // print fonksiyonunun davranışını bütün OwnedDogs sınıfı için override eder + // (üstünden geçer, kendine uyarlar). + // bknz http://en.wikipedia.org/wiki/Polymorphism_(computer_science) + // override anahtar sözcüpü kullanılma da olur ama kullanılması aslında bir temel + // temel sınıf fonksiyonunun üzerinden geçtiğimizi gösterir. + void print() const override; + +private: + std::string owner; +}; + +// Bu arada takip eden .cpp dosyasında: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Ana dog sınıfındaki print fonksiyonunu çağırır + std::cout << "Dog is owned by " << owner << "\n"; + // "Dog is <name> and weights <weight>" + // "Dog is owned by <owner>" + // yazdırır +} + +///////////////////////////////////////////////////// +// ilk değer atama ve Operatörün fazladan yüklenmesi +///////////////////////////////////////////////////// + +// C++ dilinde +, -, *, /, gibi operatörlerin davranışını fazladan yükleyebilirsiniz. +// Bu, operator her kullandınıldığında çağrılan bir fonksiyon tanımlamasıyla yapılır. + +#include <iostream> +using namespace std; + +class Point { +public: + // Üye değişkenkenlere default değer atanabilir. + double x = 0; + double y = 0; + + // Default constructor + Point() { }; + + Point (double a, double b) : + x(a), + y(b) + { /* İlk değer atama dışında birşey yapma */ } + + // + operatorünün fazladan yükle. + Point operator+(const Point& rhs) const; + + // += operatorünü fazladan yükle + Point& operator+=(const Point& rhs); + + // - ve -= operatorleri fazladan yüklemek de mantıklı olurdu + // ama kısa tutmak için burda değinmedik. +}; + +Point Point::operator+(const Point& rhs) const +{ + // yeni bir nokta oluştur ve bunu rhs ile topla + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // Bu Point + operatorünü çağırır + Point result = up + right; + // "Result is upright (1,1)" yazdırır. + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +//////////////////////// +// Şablonlar (Templates) +//////////////////////// + +// Şablonlar C++ dilinde tipten bağımsız programlama için kullanılır. + +// Zaten aşina olduğun tipten bağımsız programlamayla başladık. Bir tip parametresi +// alan fonksiyon veya sınıf tanımlamaık için: +template<class T> +class Box { +public: + // Bu sınıfta T, herhangi bir tip için kullanılabilir. + void insert(const T&) { ... } +}; + +// Derleme esnasında derleyici aslında, parametreleri yerine konmuş şekilde herbir şablonu üretir, +// bu yüzden sınıfın tam tanımı her çağrılma sırasında var olmak zorundadır. Bu nedenle şablon sınıflarını +// tamamen header dosyalarında görürsün. + +// Stack'ta şablon sınıfın bir örneğini oluşturmak için: +Box<int> intBox; + +// ve, anladığın gibi, kullanabilirsin: +intBox.insert(123); + +// Tabi, şablonları içiçe geçirebilirsin: +Box<Box<int> > boxOfBox; +boxOfBox.insert(intBox); + +// C++11'den önce iki '>' arasına boşluk koymak zorundaydık yoksa sağa kaydırma +// operatörü olarak algılanabilirdi. + +// Bazen şunu da görebilirsin +// template<typename T> +// 'class' ve 'typename' anahtar sözcükleri çoğunlukla +// birbirlerinin yerine kullanılabilir. Tam açıklama için, bknz. +// http://en.wikipedia.org/wiki/Typename +// (evet, bu anahtar sözcüğün kendi Wikipedia sayfası var). + +// Benzer şekilde, bir şablon fonksiyon: +template<class T> +void barkThreeTimes(const T& input) +{ + input.bark(); + input.bark(); + input.bark(); +} + +// Dikkat edersen tip parametresi hakkında birşey belirtilmedi. Derleyici bunları üretecek +// ve her parametre geçişinde tip-kontrolü yapacaktır, bu nedenle de fonksiyon herhangi bir T +// tipi için çalışacaktır! + +Dog fluffy; +fluffy.setName("Fluffy") +barkThreeTimes(fluffy); // Üç kere "Fluffy barks" yazdırır. + +// Şablonun parametresi sınıf olmak zorunda değildir: +template<int Y> +void printMessage() { + cout << "Learn C++ in " << Y << " minutes!" << endl; +} + +// Ve template'i daha etkili kod için dışarıdan özelleştirebilirsin. +// Tabiki gerçek-dünya kullanımlarında özelleştirme bunun kadar kolay değildir. +// Dikkat edersen, bütün parametreleri dıştan özelleştirmiş olsak bile +// hala fonksiyonu (veya sınıfı( template olarak tanımlamamız gerekli. +template<> +void printMessage<10>() { + cout << "Learn C++ faster in only 10 minutes!" << endl; +} + +printMessage<20>(); // "Learn C++ in 20 minutes!" yazdırır +printMessage<10>(); // "Learn C++ faster in only 10 minutes!" yazdırır + + +/////////////////////////////////////////////// +// İstisnai Durum Yönetimi (Exception Handling) +/////////////////////////////////////////////// + +// Standard kütüphane bazı istisnai tipler sağlar +// (bknz http://en.cppreference.com/w/cpp/error/exception) +// ama herhangi bir tip de istisnai durum fırlatabilir + +#include <exception> +#include <stdexcept> + +// _try_ bloğu içinde fırlatılan bütün istisnai durumlar, takip eden, _catch_ ile +// yakalanabilir. +try { + // _new_ kullanarak heap'ten istisnai durumlar için yer ayırma + throw std::runtime_error("A problem occurred"); +} + +// istisnai durumlar nesne ise const reference ile yakala +catch (const std::exception& ex) +{ + std::cout << ex.what(); +} + +// Bir önceki _catch_ bloğundan kaçan istisnai durum burda yakala +catch (...) +{ + std::cout << "Unknown exception caught"; + throw; // Tekrardan istisnai durum fırlatır +} + +/////// +// RAII +/////// + +// RAII, "Resource Acquisition Is Initialization" kelimelerinin kısaltmasıdır. +// Bu Türkçe, "Kaynak alımı aynı zamanda ilk değer atamasıdır." olarak çevrilebilir. +// Bunu basitçe constructor ile ayrılan hafızanın destructor ile iade edilmesi olarak +// düşünebiliriz. + +// Bunun ne şekilde kullanışlı olduğunu görmek için +// bir C dosyasının, dosya işleme biçimine bakabiliriz: +void doSomethingWithAFile(const char* filename) +{ + // Başlangıçta herşeyin yolunda gittiğini düşünelim + + FILE* fh = fopen(filename, "r"); // Dosyayı okuma modunda aç + + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + + fclose(fh); // Dosyayı kapat +} + +// Malesef hatalarla başa çıkmaya çalışırken işler hızlıca karmaşıklaşır. +// Mesela fopen'ın başarısız olduğunu varsayalım, ve doSoomethingWithTheFile ve +// doSomethingWithIt hata kodları gönderdi. +// (İstisnai durumlar yonetimi, hata koduna tercih ediler bir yöntemdir, ama bazı +// programcılar, özellikle C arkaplanı olanlar, aynı fikirde değildir. +// Bu durumda her bir fonksiyon çağrısını kontrol etmeli ve bir problem oluştuysa +// dosyayı kapatmalıyız. + +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Dosyayı okuma modunda aç + if (fh == nullptr) // Başarısız olma durumunda dönen değer null olur + return false; // Başarısız olma durumunu çağırıcıya bildir + + // Başarısız olma durumunda her iki fonksiyonun da false döndürdüğünü kabul edelim + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Dosyayı kapatalım, akıntı olmasın. + return false; // Hatayı bildir + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Dosyayı kapatalım, akıntı olmasın. + return false; // Hatayı bildir + } + + fclose(fh); // Dosyayı kapat + return true; // Başarı durumunu ifade eder +} + +// C programcıları biraz goto kullanarak bu durumu temizler +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + return false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Dosyayı kapat + return true; // Başarı durumunu ifade eder + +failure: + fclose(fh); + return false; // Hatayı bildir +} + +// Eğer fonksiyon istisnai durum yönetimi araçlarını kullanırsa +// işler daha temiz olur ama hala en iyi durumun altında kalır. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + throw std::runtime_error("Could not open the file."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Hata durumunda dosyayı kapattığından emin ol + throw; // Sonra, tekrardan istisnai durum fırlat + } + + fclose(fh); // Dosyayı kapat + // Herşey başarılı +} + +// Şimdi aynı şeyi C++'ın dosya stream sınıfıyla (fstream) karşılaştıralım +// fstream, dosyayı kapatmak için kendi destructor'ını kullanır. +// Destructor'ın, nesne scope dışına çıktığında otomatik olarak çağrıldığını +// hatırlayın. +void doSomethingWithAFile(const std::string& filename) +{ + std::ifstream fh(filename); // Dosyayı aç + + // Dosyayla birşeyler yap + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // Dosya, destructor tarafından otomatik olarak kapatıldı + +// Bunun _çok büyük_ avantajları var: +// 1. Ne olursa olursun, +// kaynak (bu örnekte dosya tutucusu) temizlenecektir. +// Destructor doğru yazıldığında, +// Tutucuyu kapatmayı unutma ve kaynak akıntısı _imkansız_dır. +// 2. Kodun çok daha temiz olduğuna dikkat edin. +// Destructor, dosyayı kapatma işini, endilenmemize gerek kalmadan +// arka planda halleder. +// 3. Kod, istisnai durumlara karşı korunaklıdır. +// İstisnai durum fonksiyonun herhangi bir yerinde fırlatılabilir ve +// temizleme işi gene de yapılır. + +// Bütün C++ kodu deyimleri RAII prensibini tüm kaynakları için kullanır. +// Ek örnekler şunlardır: +// - unique_ptr ve shared_ptr ile hafıza kullanımı +// - Tutucular - standard kütüphane linked list, +// vector (yani kendiliğinden boyu ayarlanan dizi), hash map vs. +// scope'un dışına çıktığında içerini otomatik olarak yok eden tüm yapılar. +// - lock_guard ve unique_lock kullanan mutex'ler + +/////////////////////////////////////// +// Lambda İfadeleri (C++11 ve yukarısı) +/////////////////////////////////////// + +// lambda'lar, tam olarak çağrıldığı yerde bir anonim fonksiyon tanımlamak +// veya fonksiyona argüman geçmek için uygun bir yoldur. + +// Mesela, pair'lardan oluşan bir vector'u, pair'ın ikinci değerine +// göre sıralamak isteyelim + +vector<pair<int, int> > tester; +tester.push_back(make_pair(3, 6)); +tester.push_back(make_pair(1, 9)); +tester.push_back(make_pair(5, 0)); + +// sort fonksiyonuna üçüncü argüman olarak lambda ifadesini geç +// sort, <algorithm> başlığında tanımlı + +sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) { + return lhs.second < rhs.second; + }); + +// Lambda ifadesinin söz dizimine dikkat edin, +// lambda'daki [], değişkenleri "tutmak" için kullanılır +// "Tutma listesi", fonksiyon gövdesinde nelerin, ne şekilde erişilebilir olduğunu tanımlar +// Şunlardan biri olabilir: +// 1. bir değer : [x] +// 2. bir referans : [&x] +// 3. mevcut scope içindeki herhangi bir değişkene referans ile [&] +// 4. 3 ile aynı, ama değer ile [=] +// Mesela: +vector<int> dog_ids; +// number_of_dogs = 3; +for(int i = 0; i < 3; i++) { + dog_ids.push_back(i); +} + +int weight[3] = {30, 50, 10}; + +// Mesela dog_ids vector'unu dog'ların ağırlıklarına göre sıralamak isteyelim +// Yani en sonunda şöyle olmalı: [2, 0, 1] + +// Burada lambda ifadesi oldukça kullanışlıdır + +sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) { + return weight[lhs] < weight[rhs]; + }); +// Dikkat edersen "weight" dizisini referans ile aldık. +// C++'da lambdalar hakkında daha fazla bilgi için : http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11 + +////////////////////////////////// +// Akıllı For (C++11 ve yukarısı) +////////////////////////////////// + +// Akıllı for döngüsünü bir tutucuyu dolaşmak için kullanabilirsin +int arr[] = {1, 10, 3}; + +for(int elem: arr){ + cout << elem << endl; +} + +// Tutucunun elemanlarının tipi için endişe etmeden "auto" kullanabilirsin +// Mesela: + +for(auto elem: arr) { + // arr dizisinin elemanlarıyla ilgili bir şeyler yap +} + +//////////////// +// Güzel Şeyler +//////////////// + +// C++ dilinin bakış açısı yeni başlayanlar için (hatta dili iyi bilenler için bile) +// şaşırtıcı olabilir. +// Bu bölüm, ne yazık ki, büyük ölçüde tam değil; C++ kendi ayağına ateş edilebilecek kolay +// dillerden biridir. + +// private metodları override edebilirsin! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // Foo::bar fonksiyonu override edilir! +}; + + +// 0 == false == NULL (çoğu zaman)! +bool* pt = new bool; +*pt = 0; // 'pt'nin gösterdiği değere false atar. +pt = 0; // 'pt'ye null pointer atar. Her iki satır uyarısız derlenir. + +// nullptr'ın bu meselenin bazılarını çözmesi beklenmiştir: +int* pt2 = new int; +*pt2 = nullptr; // Derlenmez. +pt2 = nullptr; // pt2'ye null atar. + +// bool tipleri için bir istisna vardır. +// Bu null pointer'ları if(!ptr) ile test etmek içindir. +// ama sonuç olarak bir bool değerine nullptr atayabilirsin! +*pt = nullptr; // '*pt' değeri bir boll olmasına rağmen, hala derlenir! + + +// '=' != '=' != '='! +// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy +// Foo::Foo(const Foo&) çağrısını veya kopyalama constructor'ının bir çeşidinin çağrısınıyapar(taşıma semantiklerine bknz.) +Foo f2; +Foo f1 = f2; + +// Foo::operator=(Foo&) çağrısını yapar. +Foo f1; +f1 = f2; + + +/////////////////////////////////////// +// Tuple (C++11 ve yukarısı) +/////////////////////////////////////// + +#include<tuple> + +// Ana fikir olarak, Tuple, eski veri yapılarına (C'deki struct'lar) benzer ama isimli veri üyeleri yerine +// elemanlarına tuple içindeki sırasına göre erişilir. + +// Tuple'ı inşa ederek başlayalım +// değişkenleri tuple içinde paketliyoruz +auto first = make_tuple(10, 'A'); +const int maxN = 1e9; +const int maxL = 15; +auto second = make_tuple(maxN, maxL); + +// 'first' tuple'ının değerlerini yazdırma +cout << get<0>(first) << " " << get<1>(first) << "\n"; // 10 A yazdırır + +// 'second' tuple'ının değerlerini yazdırma +cout << get<0>(second) << " " << get<1>(second) << "\n"; // 1000000000 15 yazdırır + +// Değişkenleri tuple'dan çıkarma + +int first_int; +char first_char; +tie(first_int, first_char) = first; +cout << first_int << " " << first_char << "\n"; // 10 A yazdırır + +// Ayrıca şu şekide de tuple oluşturabiliriz. + +tuple<int, char, double> third(11, 'A', 3.14141); +// tuple_size, tuple'daki eleman sayısını (constexpr olarak) döndürür + +cout << tuple_size<decltype(third)>::value << "\n"; // 3 yazdırır + +// tuple_cat, tuple'daki tüm elemanları aynı sırada birleştirir. + +auto concatenated_tuple = tuple_cat(first, second, third); +// concatenated_tuple = (10, 'A', 1e9, 15, 11, 'A', 3.14141) olur + +cout << get<0>(concatenated_tuple) << "\n"; // 10 yazdırır +cout << get<3>(concatenated_tuple) << "\n"; // 15 yazdırır +cout << get<5>(concatenated_tuple) << "\n"; // 'A' yazdırır + + +///////////////////// +// Tutucular +///////////////////// + +// Tutucular veya Standard Şablon Kütüphanesi(STL) önceden tanımlanmış şablonlar sunar. +// Bunlar elemanları için ayrılan hafıza alanını yönetir +// ve onlara erişim ve değiştirmek için üye fonksiyonlar sağlar + +// Bazı tutucular şunlardır: + +// Vector (Dinamik Dizi) +// koşma anında nesne dizisi veya list oluşturmamızı sağlar +#include <vector> +string val; +vector<string> my_vector; // vector'ü tanımla +cin >> val; +my_vector.push_back(val); // val değerini my_vector vectörüne push edecektir +my_vector.push_back(val); // val değerini yeniden push edecektir (şu an iki elemanı var) + +// vector içinde dolaşmak için iki seçenek var: +// ya klasik döngüyle (0. index'ten son index'e kadar iterasyon yaparak) +for (int i = 0; i < my_vector.size(); i++) { + cout << my_vector[i] << endl; // vector'ün elemanlarına uşamak için [] operatörünü kullanabiliriz +} + +// ya da iteratör kulllanarak: +vector<string>::iterator it; // vector için iterator tanımla +for (it = my_vector.begin(); it != my_vector.end(); ++it) { + cout << *it << endl; +} + +// Set(Küme) +// Set'ler benzersiz(unique) elemanları belirli bir sırada saklayan tutuculardır. +// Set, benzersiz değerleri, herhangi bir fonksiyon veya kod gerektirmeksizin, sıralı olarak + +#include<set> +set<int> ST; // int tipi için set tanımlar +ST.insert(30); // ST kümesini 30 değerini dahil eder +ST.insert(10); // ST kümesini 10 değerini dahil eder +ST.insert(20); // ST kümesini 20 değerini dahil eder +ST.insert(30); // ST kümesini 30 değerini dahil eder +// Şimdi kümedeki elemanlar aşağıdaki gibidir +// 10 20 30 + +// Bir eleman silmek için: +ST.erase(20); // 20 değerine sahip elemanı siler +// Set ST: 10 30 +// Iterator kullanarak Set içinde iterasyon yapmak için: +set<int>::iterator it; +for(it=ST.begin();it<ST.end();it++) { + cout << *it << endl; +} +// Output: +// 10 +// 30 + +// Tutucuyu tamamen silmek için Tutucu_Adi.clear() kullanırız +ST.clear(); +cout << ST.size(); // ST kümesinin eleman sayısı(size)nı yazdırır. +// Output: 0 + +// NOTE: Aynı elemanlari içerebilen kümle için multiset kullanırız + +// Map(Harita) +// Map, elemanları anahtar değer, haritalanmış değer şeklinde özel bir sırada saklar. +// anahtar_değer -> haritalanmış_değer + +#include<map> +map<char, int> mymap; // Anahtar char ve değer int olacak şekilde map tanımlar + +mymap.insert(pair<char,int>('A',1)); +// 1 değeri için A anahtar değerini ekler +mymap.insert(pair<char,int>('Z',26)); +// 26 değeri için Z anahtar değerini ekler + +// Map'te dolaşma +map<char,int>::iterator it; +for (it=mymap.begin(); it!=mymap.end(); ++it) + std::cout << it->first << "->" << it->second << '\n'; +// Output: +// A->1 +// Z->26 + +// Anahtar'a atanmış değeri bulmak için +it = mymap.find('Z'); +cout << it->second; + +// Output: 26 + + +///////////////////////////////////////////// +// Mantıksal ve Bit seviyesindeki operatörler +///////////////////////////////////////////// + +// Pek çok C++ operatörleri diğer dillerdekiyle aynıdır + +// Mantıksal operatörler + +// C++, bool ifadelerinde Kısa-devre değerlendirmesini kullanır yani ikinci argüman yalnızca ilk argüman +// ifadenin değerine karar vermek için yeterli değilse çalıştırılır + +true && false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir +true || false // **mantıksal veya** işlemi yapılır ve true sonucu üretilir +! true // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir + +// Sembolleri kullanmak yerine onlara karşılık gelen anahtar kelimeler kullanılabilir +true and false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir +true or false // **mantıksal veya** işlemi yapılır ve true sonucu üretilir +not true // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir + +// Bit seviyesindeki operatörler + +// **<<** Sola kaydırma operatörü +// << bitleri sola kaydırır +4 << 1 // 4'ün bitlerini 1 sola kaydırır ve 8 sonucunu verir +// x << n, x * 2^n olarak düşünülebilir + + +// **>>** Sağa kaydırma operatörü +// >> bitleri sağa kaydırır +4 >> 1 // 4'ün bitlerini 1 sağa kaydırır ve 2 sonucunu verir +// x >> n, x / 2^n olarak düşünülebilir + +~4 // Bit seviyesinde değil işlemini gerçekleştirir +4 | 3 // Bit seviyesinde veya işlemini gerçekleştirir +4 & 3 // Bit seviyesinde ve işlemini gerçekleştirir +4 ^ 3 // Bit seviyesinde xor işlemini gerçekleştirir + +// Eşdeğer anahtar kelimeler +compl 4 // Bit seviyesinde değil işlemini gerçekleştirir +4 bitor 3 // Bit seviyesinde veya işlemini gerçekleştiri +4 bitand 3 // Bit seviyesinde ve işlemini gerçekleştirir +4 xor 3 // Bit seviyesinde xor işlemini gerçekleştirir + + +``` +İleri okuma: + +Güncel bir referans +<http://cppreference.com/w/cpp> adresinde bulunabilir + +Ek kaynaklar <http://cplusplus.com> adresinde bulunabilir diff --git a/tr-tr/git-tr.html.markdown b/tr-tr/git-tr.html.markdown new file mode 100644 index 00000000..87c1820c --- /dev/null +++ b/tr-tr/git-tr.html.markdown @@ -0,0 +1,596 @@ +--- +category: tool +lang: tr-tr +tool: git +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Leo Rudberg" , "http://github.com/LOZORD"] + - ["Betsy Lorton" , "http://github.com/schbetsy"] + - ["Bruno Volcov", "http://github.com/volcov"] + - ["Andrew Taylor", "http://github.com/andrewjt71"] + - ["Jason Stathopulos", "http://github.com/SpiritBreaker226"] + - ["Milo Gilad", "http://github.com/Myl0g"] + - ["Adem Budak", "https://github.com/p1v0t"] + +filename: LearnGit-tr.txt +--- + +Git dağınık versiyon kontrol ve kaynak kod yönetim sistemidir. + +Bunu projenin bir seri anlık durumunu kaydederek yapar ve bu anlık durumları +kullanarak versiyon ve kaynak kodu yönetmeni sağlar. + +## Versiyonlama Konseptleri + +### Versiyon kontrol nedir? + +Versiyon kontrol, zaman içerisinde dosya(lar)daki değişikliği kaydeden sistemdir. + +### Merkezi Versiyonlama vs. Dağınık Versiyonlama + +* Merkezi versiyon kontrolü dosyaların eşitlenmesine, takibine ve yedeklenmesine odaklanır. +* Dağınık versiyon kontrolü değişimin paylaşılmasına odaklanır. Her değişiminin benzersiz bir adı vardır. +* Dağınık sistemlerin belirlenmiş bir yapısı yoktur. Git ile kolayca SVN'deki gibi merkezi bir sistem elde edebilirsin. + +[Daha fazla bilgi](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### Neden Git? + +* Çevrimdışı çalışabilir +* Diğerleriyle beraber çalışmak kolaydır! +* Dallanma kolaydır! +* Dallanma hızlıdır! +* Git hızlıdır +* Git esnektir + +## Git Mimarisi + +### Repository + +Bir grup dosya, dizin, geriye dönük kayıt, commit, head. Bunları kaynak kodun veri +yapısı gibi düşünebilirsin, herbir kaynak kod "elemanı" seni kendi revizyon geçmişine +eriştirir. + +Bir git repo'su .git dizini ve çalışma ağacından oluşur. + +### .git Dizini (repository bileşeni) + +.git dizini bütün konfigrasyon, log, dallanma, HEAD ve daha fazlasını tutar. +[detaylı liste](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### Çalışma Ağacı (repository bileşeni) + +Temelde repo'daki dizinlerin ve dosyalarındır. Sıkça çalışma ağacın olarak anılır. + +### Index (.git dizininin birleşeni) + +Index git'in evreleme alanıdır (staging area). Temelde çalışma ağacını Git repo'sundan +ayıran bir katmandır. Bu geliştiricilere neyin Git repo'suna gönderileceği hakkında daha +fazla güç verir. + +### Commit + +Bir git commit'i Çalışma Ağacındaki bir takım değişiklerdir. Mesela 5 tane dosya +eklemişsindir ve diğer 2 tanesini silmişindir, bu değişikler commit'te (anlık kayıtta) +tutulacaktır. Bu commit daha sonra diğer repo'lara bastırılabilir (pushed) ve bastırılmaz! + +### Branch + +Bir branch esasen yaptığın son commit'e göstericidir(pointer). Commit'lemeye devam ettiğinde, +bu gösterici otomatik olarak son commit'e güncellenir. + +### Tag + +Bir tag, tarihteki belirli bir noktanın işaretidir. İnsanlar bunu genelde +sürüm notları için kullanır (v1.0 vs.) + +### HEAD ve head (.git dizininin birleşenleri) + +HEAD mevcut branch'a bir göstericidir. Bir repository yalnızca 1 *aktif* +HEAD'e sahiptir. +head, commit'e bir göstericidir. Bir repository herhangi bir sayıda head'e sahip olabilir. + +### Git'in Stage'leri +* Modified - Dosyada değişikler yapıldı ama henüz Git Veritabanına commit yapılmadı. +* Staged - Modified edilmiş bir dosyayı, sonraki commit'e gitmek üzere işaretler. +* Committed - Dosyalar Git Veritabanına commit'lendi. + +### Kavramsal Kaynaklar + +* [Bilgisayar Bilimciler için Git](http://eagain.net/articles/git-for-computer-scientists/) +* [Tasarımcılar için Git](http://hoth.entp.com/output/git_for_designers.html) + +## Komutlar + +### init + +Boş bir Git repository'si oluştur. Git repository'sinin ayarları, depolanmış +bilgileri ve daha fazlası ".git" adlı dizinde (bir klasör) tutulur. + +```bash +$ git init +``` + +### config + +Ayarları yapılandırmak için. Repository, sistemin kendisi veya global yapılandırmalar +için olarabilir. (global yapılandırma dosyası `~/.gitconfig`). + +```bash +# Print & Set Some Basic Config Variables (Global) +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[git config hakkında daha fazla bilgi için.](http://git-scm.com/docs/git-config) + +### help + +Her bir komutun detaylı kılavuzuna hızlı bir erişim için. Ya da sadece bazı şeylerin +anlamı için hızlı bir hatırlatıcı için. + +```bash +# Quickly check available commands +$ git help + +# Check all available commands +$ git help -a + +# Command specific help - user manual +# git help <command_here> +$ git help add +$ git help commit +$ git help init +# or git <command_here> --help +$ git add --help +$ git commit --help +$ git init --help +``` + +### dosyaları ignore etme + +git'in bazı dosya(ları) ve klasör(leri) kasıtlı olarak takip etmemesi için. Genel +olarak,repository'de ne de olsa paylaşılacak, private ve temp dosyaları için. + +```bash +$ echo "temp/" >> .gitignore +$ echo "private_key" >> .gitignore +``` + +### status + +index dosyası(temelde çalıştığın repo) ve mevcut HEAD commit arasındaki farkı göstermek için. + +```bash +# Will display the branch, untracked files, changes and other differences +$ git status + +# To learn other "tid bits" about git status +$ git help status +``` + +### add + +Dosyaları staging area'ya eklemek için. Eğer yeni dosyaları staging area'ya `git add` +yapmazsanız, commit'lere eklenmez! + +```bash +# add a file in your current working directory +$ git add HelloWorld.java + +# add a file in a nested dir +$ git add /path/to/file/HelloWorld.c + +# Regular Expression support! +$ git add ./*.java + +# You can also add everything in your working directory to the staging area. +$ git add -A +``` +Bu yalnızca dosyayı staging area'a/index'e ekler, çalışılan dizine/repo'ya commit etmez. + +### branch + +Branch'ları yönetir. Bu komutu kullanarak, branch'ları görebilir, düzenleyebilir, oluşturabilir, silebilirsin. + +```bash +# list existing branches & remotes +$ git branch -a + +# create a new branch +$ git branch myNewBranch + +# delete a branch +$ git branch -d myBranch + +# rename a branch +# git branch -m <oldname> <newname> +$ git branch -m myBranchName myNewBranchName + +# edit a branch's description +$ git branch myBranchName --edit-description +``` + +### tag + +tag'leri yönetir + +```bash +# List tags +$ git tag + +# Create a annotated tag +# The -m specifies a tagging message, which is stored with the tag. +# If you don’t specify a message for an annotated tag, +# Git launches your editor so you can type it in. +$ git tag -a v2.0 -m 'my version 2.0' + +# Show info about tag +# That shows the tagger information, the date the commit was tagged, +# and the annotation message before showing the commit information. +$ git show v2.0 + +# Push a single tag to remote +$ git push origin v2.0 + +# Push a lot of tags to remote +$ git push origin --tags +``` + +### checkout + +index'in versiyonun eşlemek için çalışma ağacındaki,veya belirtilen ağactaki, tüm dosyaları günceller. + +```bash +# Checkout a repo - defaults to master branch +$ git checkout + +# Checkout a specified branch +$ git checkout branchName + +# Create a new branch & switch to it +# equivalent to "git branch <name>; git checkout <name>" + +$ git checkout -b newBranch +``` + +### clone + +Varolan bir repository'i yeni bir dizine clone'lar veya kopyalar. +Ayrıca clone'lanmış repodaki her bir branch için, uzak branch'a bastırmana izin veren, +uzak takip branch'ları ekler. + +```bash +# Clone learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git + +# shallow clone - faster cloning that pulls only latest snapshot +$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git + +# clone only a specific branch +$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch +``` + +### commit + +index'in mevcut içeriğini yeni bir "commit"te saklar. Bu commit, kullanıcının oluşturduğu +bir mesajı ve yapılan değişiklikleri saklar. + +```bash +# commit with a message +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" + +# signed commit with a message (user.signingkey must have been set +# with your GPG key e.g. git config --global user.signingkey 5173AAD5) +$ git commit -S -m "signed commit message" + +# automatically stage modified or deleted files, except new files, and then commit +$ git commit -a -m "Modified foo.php and removed bar.php" + +# change last commit (this deletes previous commit with a fresh commit) +$ git commit --amend -m "Correct message" +``` + +### diff + +Shows differences between a file in the working directory, index and commits. +Bir dosyanın, çalışma ağacı, index ve commit'ler arasındaki farklarını göster. + +```bash +# Show difference between your working dir and the index +$ git diff + +# Show differences between the index and the most recent commit. +$ git diff --cached + +# Show differences between your working dir and the most recent commit +$ git diff HEAD +``` + +### grep + +Bir repository'de hızlıca arama yapmana izin verir. + +İsteğe Bağlı Yapılandırmalar: + +```bash +# Thanks to Travis Jeffery for these +# Set line numbers to be shown in grep search results +$ git config --global grep.lineNumber true + +# Make search results more readable, including grouping +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Search for "variableName" in all java files +$ git grep 'variableName' -- '*.java' + +# Search for a line that contains "arrayListName" and, "add" or "remove" +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +Daha fazla örnek için +[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Repository'deki commitleri gösterir. + +```bash +# Show all commits +$ git log + +# Show only commit message & ref +$ git log --oneline + +# Show merge commits only +$ git log --merges + +# Show all commits represented by an ASCII graph +$ git log --graph +``` + +### merge + +Dış commit'lerdeki değişiklikleri mevcut branch'a "merge" et (birleştir). + +```bash +# Merge the specified branch into the current. +$ git merge branchName + +# Always generate a merge commit when merging +$ git merge --no-ff branchName +``` + +### mv + +Bir dosyayı yeniden taşı veya yeniden adlandır + +```bash +# Renaming a file +$ git mv HelloWorld.c HelloNewWorld.c + +# Moving a file +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Force rename or move +# "existingFile" already exists in the directory, will be overwritten +$ git mv -f myFile existingFile +``` + +### pull + +Bir repository'den çeker ve diğer branch'a merge eder. + +```bash +# Update your local repo, by merging in new changes +# from the remote "origin" and "master" branch. +# git pull <remote> <branch> +$ git pull origin master + +# By default, git pull will update your current branch +# by merging in new changes from its remote-tracking branch +$ git pull + +# Merge in changes from remote branch and rebase +# branch commits onto your local repo, like: "git fetch <remote> <branch>, git +# rebase <remote>/<branch>" +$ git pull origin master --rebase +``` + +### push + +Bir branch'taki değişikleri, uzak branch'a bastır ve birleştir. + +```bash +# Push and merge changes from a local repo to a +# remote named "origin" and "master" branch. +# git push <remote> <branch> +$ git push origin master + +# By default, git push will push and merge changes from +# the current branch to its remote-tracking branch +$ git push + +# To link up current local branch with a remote branch, add -u flag: +$ git push -u origin master +# Now, anytime you want to push from that same local branch, use shortcut: +$ git push +``` + +### stash + +Stash'leme çalışma dizinindeki kirli durumu alır ve bitmemiş değişiklikler +yığınına kaydeder. Bu değişikleri istediğin zaman tekrar uygulayabilirsin. + +Mesela git repo'nda bazı işler yaptın ama remote'dan pull yapmak istiyorsun. +Bazı dosyalarında kirli (commit'lenmemiş) değişiklikler olduğundan `git pull` +yapamazsın. Onun yerine önce `git stash` ile değişikliklerini yığına kaydet! + +(stash, sözlük anlamı: bir şeyi, özel bir yere güvenli biçimde saklamak) + +```bash +$ git stash +Saved working directory and index state \ + "WIP on master: 049d078 added the index file" + HEAD is now at 049d078 added the index file + (To restore them type "git stash apply") +``` + +Şimdi pull yapabilirsin! + +```bash +git pull +``` +`...changes apply...` + +Herşeyin tamam olduğunu kontrol et + +```bash +$ git status +# On branch master +nothing to commit, working directory clean +``` +Şu ana kadar neleri stash'lediğini `git stash list` kullanarak görebilirsin. +Stash'lenen şeyler Son-Giren-İlk-Çıkar şeklinde tutulduğundan en son değişim +en üste olacaktır. + +```bash +$ git stash list +stash@{0}: WIP on master: 049d078 added the index file +stash@{1}: WIP on master: c264051 Revert "added file_size" +stash@{2}: WIP on master: 21d80a5 added number to log +``` +Şimdi de kirli değişiklileri yığından çıkarıp uygulayalım. + +```bash +$ git stash pop +# On branch master +# Changes not staged for commit: +# (use "git add <file>..." to update what will be committed) +# +# modified: index.html +# modified: lib/simplegit.rb +# +``` + +`git stash apply` da aynı şeyi yapar + +Şimdi kendi işine dönmeye hazırsın! + +[Ek Okuma.](http://git-scm.com/book/en/v1/Git-Tools-Stashing) + +### rebase (dikkat) + +Branch'ta commit'lenen tüm değişimleri al ve onları başka bir branch'ta tekrar oynat +*Public repo'ya push edilmiş commit'leri rebase etme* + +```bash +# Rebase experimentBranch onto master +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[Ek Okuma.](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (dikkat) + +Reset the current HEAD to the specified state. This allows you to undo merges, +pulls, commits, adds, and more. It's a great command but also dangerous if you +don't know what you are doing. + +HEAD'i belirtilen duruma resetle. Bu merge'leri, pull'ları, commit'leri, add'leri +ve daha fazlasını geriye almanı sağlar. Muhteşem bir komuttur ama aynı zamanda, ne +yaptığını bilmiyorsan, tehlikelidir. + +```bash +# Reset the staging area, to match the latest commit (leaves dir unchanged) +$ git reset + +# Reset the staging area, to match the latest commit, and overwrite working dir +$ git reset --hard + +# Moves the current branch tip to the specified commit (leaves dir unchanged) +# all changes still exist in the directory. +$ git reset 31f2bb1 + +# Moves the current branch tip backward to the specified commit +# and makes the working dir match (deletes uncommitted changes and all commits +# after the specified commit). +$ git reset --hard 31f2bb1 +``` + +### reflog (dikkat) + +Reflog, verilen zaman içinde,default olarak 90 gündür, yaptığın git komutlarını listeler. + +Bu sana beklemediğin şekilde yanlış giden komutları geriye çevirme şansı verir. +(mesela, eğer bir rebase uygulamanı kırdıysa) + +Şu şekilde yapıbilirsin: + +1. `git reflog` rebase için tüm git komutlarını listele + +``` +38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog +38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators +4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown +34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666) +ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748) +2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d +``` +2. Nereye reset'leyeceğini seç, şu durumda `2e6c386` veya `HEAD@{5}` +3. 'git reset --hard HEAD@{5}' bu repo'nu seçilen head'e eşitler +4. Rebase'e yeniden başlayabilir veya onu yalnız bırakabilirsin. + +[Ek Okuma.](https://git-scm.com/docs/git-reflog) + +### revert + +Revert commit'leri geri almada kullanılır. Projenin durumunu önceki bir noktaya +alan reset ile karıştırılmamalıdır. Revert, belirtilen commit'in tersine yeni bir +commit ekleyecektir. + +```bash +# Revert a specified commit +$ git revert <commit> +``` + +### rm + +git add'in tersine, git rm çalışma ağacından dosyaları kaldırır. + +```bash +# remove HelloWorld.c +$ git rm HelloWorld.c + +# Remove a file from a nested dir +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## Daha Fazla Bilgi + +* [tryGit - Git'i öğrenmek için eğlenceli interaktif bir yol](http://try.github.io/levels/1/challenges/1) + +* [Git Dallanmayı Öğren - Git'i web üzerinde öğrenmek için en görsel ve interaktif yol](http://learngitbranching.js.org/) + +* [Udemy Git Tutorial: Kapsayıcı bir kılavuz](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/) + +* [Git Immersion - Git'in temelinden başlayan bir tur](http://gitimmersion.com/) + +* [git-scm - Video Tutorial](http://git-scm.com/videos) + +* [git-scm - Dökümantasyon](http://git-scm.com/docs) + +* [Atlassian Git - Tutorial & Workflow](https://www.atlassian.com/git/) + +* [SalesForce Kopya Kağıdı](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) + +* [Git - Basit bir kılavuz](http://rogerdudler.github.io/git-guide/index.html) + +* [Pro Git](http://www.git-scm.com/book/en/v2) + +* [Yeni başlayanlar için Git ve Github](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners) diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown index b8f11e39..6caba1da 100644 --- a/tr-tr/markdown-tr.html.markdown +++ b/tr-tr/markdown-tr.html.markdown @@ -11,7 +11,7 @@ filename: markdown-tr.md Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır. -```markdown +```md <!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız, |