Bu sunumda, Java'nın desteklediği iki önemli üstkavram anlatılıyor: ayrıksı durumlar ve kalıtlama. Ek olarak, nesnelerin değişmelerinin nasıl önüne geçilebileceği Cloneable arayüzünün gerçekleştirimiyle anlatılırken, Java ortamında karşılaştırılabilirlik kategorisini tanımlayan java.util.Comparable arayüzünün gerçekleştirim örneği de veriliyor.
NOT: Sunum içindeki bağlantılara tıklayarak daha ayrıntılı bilgilerin verildiği makalelere ulaşabilirsiniz.
This document provides an introduction to Simultaneous Localization and Mapping (SLAM) through a tutorial approach. It discusses the hardware used for SLAM, including robots and range measurement devices. It then outlines the basic SLAM process, which involves landmark extraction from sensor data, data association to match current observations with past landmarks, and using an Extended Kalman Filter to estimate the robot's location and update landmark positions as it moves. Code examples are provided to interface with a SICK laser scanner and Evolution Robotics ER1 robot. The document aims to provide a practical understanding of SLAM that allows implementing a basic SLAM system.
Bu sunumda, Java'nın desteklediği iki önemli üstkavram anlatılıyor: ayrıksı durumlar ve kalıtlama. Ek olarak, nesnelerin değişmelerinin nasıl önüne geçilebileceği Cloneable arayüzünün gerçekleştirimiyle anlatılırken, Java ortamında karşılaştırılabilirlik kategorisini tanımlayan java.util.Comparable arayüzünün gerçekleştirim örneği de veriliyor.
NOT: Sunum içindeki bağlantılara tıklayarak daha ayrıntılı bilgilerin verildiği makalelere ulaşabilirsiniz.
This document provides an introduction to Simultaneous Localization and Mapping (SLAM) through a tutorial approach. It discusses the hardware used for SLAM, including robots and range measurement devices. It then outlines the basic SLAM process, which involves landmark extraction from sensor data, data association to match current observations with past landmarks, and using an Extended Kalman Filter to estimate the robot's location and update landmark positions as it moves. Code examples are provided to interface with a SICK laser scanner and Evolution Robotics ER1 robot. The document aims to provide a practical understanding of SLAM that allows implementing a basic SLAM system.
İnternet'te Güvenli Alışveriş için ÖnerilerAlper Başaran
İnternet'te güvenli alışveriş yapmak için dikkat etmemiz gereken bazı basit noktaları hacker'ın da bakış açısını vererek ele aldım. Daha güvenli internet kullanımına katkısı olması dileği ile..
The document discusses Python metaprogramming. It provides examples of decorators, class decorators, and metaclasses in Python. Decorators allow adding new functionality to existing functions or methods without permanently changing them. Class decorators modify classes. Metaclasses allow controlling class creation and customizing class objects. The document demonstrates how metaprogramming techniques like decorators and metaclasses can add capabilities like logging and validation to functions and classes.
Kişisel Verilerin Korunması Kanunu 7 Nisan 2016 tarihinde Resmi Gazete'de yayınlandı. 7 Ekim 2016 tarihinden itibaren tüm maddeleri ile yürürlüğe girecek olan kanun hem gerçek hem tüzel kişileri yakından ilgilendiren hükümlere yer veriyor.
RECOVERY: Olay sonrası sistemleri düzeltmekAlper Başaran
Siber saldırıların sayısında görülen artış ve saldırganların beceri düzeyinde gözlemlenen iyileşme sonucunda kuruluşların bir siber güvenlik ihlali yaşama ihtimalleri artmaktadır.
Saldırıyı önlemeye odaklanan siber güvenlik yaklaşımının pek çok kuruluş için yetersiz kaldığını gözlemlediğimiz yüzlerce olay yaşandı ve yaşanmaya devam ediyor. Günümüz şartlarında bir kuruluşun siber güvenlik ihlali yaşaması halinde yapacaklarını bilmesi ve olay sonrası durumunu/sistemlerini düzeltmek için izleyeceği bir metodolojiye sahip olması çok önemlidir.
Bu webinarımızda yaşanması muhtemel bir siber güvenlik olayı sonrasında yapılması gerekenleri ve izlenmesi gereken yolu ele alacağız.
Webinarın amacı
Kuruluş bünyesinde, ağır veya hafif etkili, yaşanacak bir güvenlik ihlali sonrasında izlenebilecek bir yol haritası paylaşmak.
Kimler katılmalı
BT Birim çalışanları ve yöneticileri, risk birimi yöneticileri, SOME (Siber Olaylara Müdahale Ekibi) üyeleri
APT (Advanced Persistent Threat - Gelişmiş Devamlı Tehdit) saldırıları konusunda düzenlediğim seminere ait sunumun bir kısmıdır. Sunum içerisinde yer alan konu başlıkları buradadır, sunumun tamamını dağıtımını kontrol edebilmek ve içerisindeki hassas bilgilerin korunması amacıyla paylaşmıyorum.
Bu sunum web uygulamalarının kritikliği ne kadar düşük olursa olsun uygulama açıklıklarının sistem ve ağ güvenliğini tehdit edebileceğini göstermektedir.
Bu döküman Adli Bilişim Nedir?,Adli Bilişim Uzmanı ne yapar?,Nasıl Adli Bilişim Uzmanı olunur ve hangi sertifakalar alınır gibi temel konuları anlatmak için hazırlanmıştır.Sunumda Adli Bilişimde kullanılan araçların isimlerinide yer verilmiştir.Umarım işinize yarar. www.gurelahmet.com ve ahmetgurel.yazilim@gmail.com üzerinden ulaşabilirsiniz.
Drupal Coder Zafiyet Analizi & İstismar Kodu GeliştirimesiMehmet Ince
Geçtiğimiz ay, popüler bir Drupal modülü üzerinde kritik güvenlik açığı yaması Drupal Security ekibi tarafından yayınlanmıştı.
Bu zafiyetin PoC kodunun internete düşmemesi, bildiğimiz kadarıyla Core Security firmasında çalışan güvenlik araştırmacılarının henüz zafiyeti ciddi anlamda tetikleyici yöntem bulamamış olmaları, şahsım adına benim ilgimi çeken nokta olmuştu. 2 gün süren çalışmanın neticesinde stabil çalışan bir uzaktan komut çalıştırma zafiyetini tespit edip ve metasploit modülünü geliştirdik.
Zafiyetin son derece basit olmasına karşın, sömürme yönteminin son derece karmaşık olması güzel bir case-study ortaya koyduğu kanaatindeyim.
Bu nedenle, tüm süreci anlatan ve 19. sayfa süren "Drupal Coder Vulnerability Analysis & Metasploit Module Dev" başlıklı Türkçe zafiyet analizi yazımızı sizlerle paylaşmak istedim.
Özgür Yazılım Günleri 2015'de yaptıgım Ruby ile MetaProgramming'e Giriş sunumun silde'ları.
Sunum kodları: https://github.com/enderahmetyurt/ruby_meta_prog/
Real time machine learning proposers day v3mustafa sarac
This document discusses DARPA's Real Time Machine Learning (RTML) program. The objective is to develop hardware generators and compilers that can automatically create application-specific integrated circuits for machine learning from high-level code. This would allow no-human-in-the-loop creation of efficient neural network hardware. The program has two phases: phase 1 develops an ML hardware compiler, and phase 2 demonstrates RTML systems for applications like wireless communication and image processing. Key goals are high performance, low power consumption, and support for a variety of neural network architectures and machine learning techniques.
This document summarizes Christoph Janz's model of the 8 ways to build a $100 million SaaS company based on pricing and customer counts. It plots 818 private SaaS companies on a chart showing their average customer price vs. customer count. Most companies with $10k-$100k average price and 100-1,000 customers fall between $1 million to $100 million in annual recurring revenue. The document examines which categories - hunting "deer", "rabbits", etc. - companies fall into and the likelihood of achieving different revenue milestones based on pricing strategies. Focusing on $100k average price to "elephants" gives the highest chance of exceeding $1 million in annual recurring revenue
The document provides instructions for manually programming the settings on an Axial AE-2 ESC without using a computer. There are three main settings that can be adjusted: 1) LiPo cutoff voltage, 2) drag brake amount, and 3) reverse/brake type. The instructions describe entering programming mode by powering on the ESC while holding full throttle on the transmitter. Each setting option will be beeped and the user indicates yes or no to cycle through and select options.
NumPy is the primary library for array programming in Python. It provides a multidimensional array object and array-aware functions that operate on the array. NumPy arrays store data and metadata like data type, shape, and strides to efficiently access and manipulate multidimensional data. Users interact with NumPy arrays using indexing to access elements and subarrays, operators for element-wise operations, and functions that perform vectorized calculations on entire arrays. NumPy handles looping over array elements to optimize performance while providing a simple and powerful programming interface for scientific computing in Python.
This document is a draft of a book on mathematics for programmers. It covers various topics in mathematics including prime numbers, modular arithmetic, probability, combinatorics, Galois fields, and logarithms. The document provides explanations, examples, and applications of these mathematical concepts for use in computer programming. It is intended to help programmers understand and apply core mathematical principles in their work.
The document provides a review of the book "The Book of Why" by Judea Pearl and Dana Mackenzie. It summarizes the book's goal of changing how data is interpreted by promoting causal inference over purely observational studies. It discusses Pearl's "Ladder of Causation" and how methods have evolved from purely statistical association to interventions and counterfactual analysis. The review provides examples of how Pearl's graphical causal models and do-operator can help determine causation in cases like the link between smoking and lung cancer.
Solitary bees nest individually in small holes or tunnels in the ground, dead wood, or human-made structures like bee houses. Bee houses provide nesting sites for solitary bees by containing drilled blocks of wood or cardboard tubes with holes of varying diameters. Proper siting in full sun and periodic management of the bee house, such as replacing materials every couple years, helps encourage solitary bee populations while preventing disease.
How did Software Got So Reliable Without Proof?mustafa sarac
This document summarizes the key techniques that have enabled software to become more reliable without extensive use of formal proof methods. It argues that software reliability has improved due to:
1) Rigorous management processes such as design reviews, quality assurance testing, and continuous error removal from existing software.
2) Techniques like defensive programming and over-engineering that increase reliability without proof.
3) Formal methods providing conceptual frameworks and basic understanding to support best practices and guide future improvement, even if not used directly in large-scale programming.
Staff Report on Algorithmic Trading in US Capital Marketsmustafa sarac
This report summarizes the benefits and risks of algorithmic trading in U.S. capital markets as required by Congress. It provides an overview of the structure of equity and debt markets and how algorithms are used in trading. The report finds that algorithmic trading has generally improved market quality and liquidity during normal periods, but may exacerbate volatility during stress. It also notes operational risks from increased complexity and interconnection of markets. The report makes no policy recommendations but provides information for regulators to consider.
This document provides a summary of the key points from the document "Consumer-Centric API Design".
1. The document discusses best practices for designing APIs that are consumer-centric and easy for developers to use. It emphasizes data abstraction, using common HTTP methods and patterns, and focusing on the needs of API consumers.
2. The author advocates designing APIs around core CRUD concepts to abstract complex business logic and data structures. Real-world examples show both good and bad approaches to data abstraction.
3. Additional chapters will cover topics like HTTP requests and responses, API versioning, authentication, permissions, documentation and testing. The goal is for readers to understand how to build APIs that third-party developers will enjoy
The survey received responses from over 650 software developers building microservices around the world. The top findings were that developers enjoy building microservices to solve scalability issues and improve performance. However, maintenance and debugging were identified as challenges. JavaScript and TypeScript were reported as the main programming languages used for microservices by 65% of respondents, showing their growing popularity. Nearly half of developers surveyed said they use AWS for deployment and serverless technologies.
This document outlines a proposal for UberCab, a next-generation on-demand car service that uses smartphone apps and GPS technology. Key aspects include:
1) Providing a luxury car service that can be requested with one click and guarantees fast pickup times, unlike traditional taxis.
2) Operating a membership-only model with professional clientele to avoid expensive medallion licenses.
3) Using the latest location-based technologies like geo-aware auto-dispatch to optimize routes and minimize wait times.
Wireless solar keyboard k760 quickstart guidemustafa sarac
This document provides instructions for setting up and using the Logitech Wireless Solar Keyboard K760. It describes how to turn the keyboard on and off, check the battery status, pair the keyboard with up to three Apple devices using Bluetooth, switch between paired devices, troubleshoot issues, and dispose of batteries at the end of the product life. The keyboard uses solar power to charge its internal batteries and includes media keys and shortcuts for Mac functions.
This document is a report on the state of serverless technologies in 2020. It includes the following key findings:
- 75% of surveyed companies have used serverless technologies, with 44% having 1-2 years of experience. The top benefits are improved performance, scaling flexibility, and reduced costs. The biggest challenges are debugging and architectural complexity.
- The most popular use cases for serverless are REST APIs, data processing, and scheduled jobs. Over half of respondents' services utilize serverless architectures.
- AWS Lambda is the dominant serverless computing vendor. The Serverless Framework is the most commonly used serverless development tool.
So in summary, this report examines adoption trends, benefits, challenges,
This document is a preview of the book "Don't Just Roll The Dice" by Neil Davidson, which provides guidance on pricing software products. It discusses how two young engineers, Hewlett and Packard, initially priced their first product in a random way based on a political slogan rather than costs or competitors. The document then provides an introduction to demand curves and how understanding customer demand at different price points can help maximize total revenue. It also discusses the importance of understanding what your actual product is beyond just the software, and how customers' perceived value of a product may differ from its objective value.
1. İndeks
Giriş
Fonksiyonlar
function(argümanlar){ return argüman }
(argüman1,argüman2,argüman3...)
var islem = function(){}
function islem(){}
function topla(sayi1,sayi2){
return sayi1+sayi2
}
İleri Seviye Javascript
Yazan: Azer Koçulu
Giriş
Fonksiyonlar
1.
1.
1.
1.
1.
1.
1.
1.
Parantez Blokları
Argümanlar
Fonksiyonlar İçin Method ve Alt Değişken Tanımlamak
Apply
Call
Prototype
Caller
Bölüm Sonu Pratikleri
Diziler
Nesneler
İleri Seviye OOP
Bu dökümanda Javascript'in deneyselliğe dayanan doğasına uygun biçimde, web tabanlı program üretmenizi sağlayacak bilgileri vermeye
çalıştım. Özellikle üstünde durmanız gereken konu olan fonksiyonlarda, kitaplarda yeralmayan ileri teknik ve pratikleri anlattım.
Dökümandan iyi verim almak için, Rainbow9'dan faydalanabilirsiniz. Rainbow9, geçen yıl hazırladığım, javascript deneyleri yapmayı ve
web tabanlı programlar geliştirmeyi sağlayan bir programdır.İsterseniz Firefox'un Firebug eklentisinden de faydalanabilirsiniz.Rainbow9,
Firebug'ın aksine bazı mobil tarayıcılar dahil tüm tarayıcılarda kurulmaya gerek olmadan çalışır.
Rainbow9: http://www.rainbow9.org Firebug: http://www.getfirebug.com
Dökümanı okuyup bitirdikten sonra daha deneysel ve iyi tekniklerle kod yazacağınızı, kod standartınızı geliştireceğinizi umut ediyorum.
Sabır ve gayretlerinizin karşılığını almanız dileğiyle,
Azer Koçulu <http://azer.kodfabrik.com>
Destekleyen, yardım eden, moral verenlere teşekkür ederim: Annem Nuray Koçulu, Can Çatalyürek, Hakan Bilgin, Muhammed Daud
C tabanlı dillerde her iş veya alt iş fonksiyonlar tarafından yürütülür.Fonksiyonların genel kullanım şekli, argüman tünelinden veri gönderip, bilgi
çıkışı beklemektir.Genel yazılışı inceleyelim:
Gönderilen argümanlar herhangi bir türde olabilir, sayı, dizi fonksiyon...Buradaki tek dikkat unsuru argümanların her birine ayrı tanıtıcı
belirlenmesidir.Argümanlar birden fazlaysa birbirlerinden virgülle ayrılmaları gerekir:
ECMAScript'in kullandığımız sürümünde, argümanlar için PHP veya Python dillerinde olduğu gibi varsayılan değer atanamaz.Değer atanmayan
argümanların tanıtıcıları yine tanımlanır ancak "undefined" türünde olurlar.Argümanlar sadece tanımlandıkları fonksiyonda çalıştırılabilirler.Global
blokta tanımlanan değişkenlere fonksiyonlardan erişilebilir.
Bir fonksiyonda en son, fonksiyondan geriye değer döndürülmesini sağlayan "return" ifadesi çalıştırılır.Eğer bu ifadeden sonra fonksiyonun içeriği
bitmediyse, ECMAScript bu içeriği görmezden gelir.
Fonksiyonlar çeşitli biçimlerde tanımlanabilir, ilk olarak tanıtıcı ve eşit işareti kullanarak klasik biçimde tanımlayalım:
Biraz daha pratik olan diğer yöntemdeyse pek çok programlama dilinden alışık olduğumuz biçimde tanımlıyoruz:
Örnek olarak argüman tünelinden aldığı iki sayının toplamı geriye döndüren bir fonksiyon tanımlayalım:
Bu biçimlerde tanımlamalar genelde tercih edilse de, bazen programın akışına göre şekillenmesi gereken fonksiyon tanımlamaya ihtiyaç
duyulur.Bu durumda tanıtıcıların program çalıştırılmadan önce belirlenmek zorunda olması, pek çok dilde rastladığımız bir kısıtlamadır.Fakat
2. var topla = new Function("sayi1","sayi2","return sayi1+sayi2")
>>> var sonuc = topla(5,4)
9
>>> var durum = 'Negatif';
>>> var durumuAyarla = function(){
durum = 'pozitif'
}
>>> durumuAyarla()
undefined
>>> durum
'pozitif'
Parantez Blokları
>>> 1+2*3
7
>>> (1+2)*3
9
>>> 1.toString()
missing ; before statement
[Break on this error] 1.toString()
javascript: with ... (line 1)
>>> 1.0.toString()
"1"
>>> (1).toString()
"1"
>>> var merhaba = function(){
return "Merhaba"
}
>>> merhaba();
Merhaba
>>> (var merhaba = function(){
alert("Merhaba");
})();
"Merhaba"
>>> (function(){
alert("Merhaba");
})();
"Merhaba"
ECMAScript'in Function() nesnesi sayesinde, kod bloğu tanıtıcı string tipinde belirtilerek, programın akışına göre şekillenen fonksiyonlar
tanımlanabilmektedir:
Fonksiyonların atama işlemleri diğer veri türleriyle aynı olsa da, fonksiyona ulaşıp çalıştırma işlemi ayrı biçimdedir.Bir fonksiyonu çalıştırmak için
tanıtıcıyla beraber argüman tüneli kullanılır.Burada argüman tünelinin veri transferi yapıp yapmaması farketmez.Örnek olarak hazırladığımız topla
fonksiyonunu kullanalım:
"sonuc" değişkeni integer türünde 9 değerini aldı.
Örnekteki topla() fonksiyonunda hem bilgi girişi hem de bilgi çıkışı yapılıyor, şimdi bilgi girişi veya çıkışı yapılmayan bir örneği inceleyelim:
Bu örnekteyse programın global bloğunda "durum" adında bir değişken ve "durumuAyarla" adında, "durum" değişkeninin değerini string tipinde
"pozitif" değeriyle değiştiren bir fonksiyon oluşturuluyor.Çalıştırıp deneyelim;
Fonksiyon tipindeki verilerin çalışmasını incelediğimiz örneklerde parantezlerin sağladığını görüyoruz.Parantezler işlevsel olarak pek çok konuda
fayda sağlasa da, pek çok zaman yazılan kodun daha anlaşılır olması için blok oluşturmada kullanılır.Önce ne gibi işlevlerde kullandığımıza
gözatalım.Birinci örnek matematiksel işlemlerde gruplama yaparken kullanılan parantezler üzerine:
İkinci örnek, sayısal değerlerin ondalık kısmıyla methodların karışması problemine parantez çözümü:
Gelelim üçüncü örneğe.Ecmascript'te her fonksiyon bloğu parantezler içine alınabilir.Ve elbette, parantez içine alınmış kod bloğuna çalıştırma
komutu gönderilebilir.Bu yöntem daha sade ve temiz görünen kodlar yazmayı sağlar, çünkü fonksiyonu yazdıktan sonra tanıtıcıyı çağırmaya gerek
duyulmaz.
Klasik yöntemle yazılan bir fonksiyonun çağırma işlemiyle, parantez bloğunun kodlarını karşılaştıralım:
İlk örnekte fonksiyonu tanımladık ve ardından tanıtıcısını kullanarak çalıştırdık, ikinci örnekteyse fonksiyonu parantez bloklarının içine alıp
çalıştırdığımız için, tanıtıcıyla çağırma yaptığımız satıra gerek kalmadı.Tahmin edeceğiniz üzere, aslında parantez bloklarını kullanırken tanıtıcı
kullanılmayabilir:
3. Argümanlar
>>> var argumanlar = function(){
return arguments;
}
>>> argumanlar(3,5);
3,5
>>>
>>> var toplama = function(){
return arguments[0]+arguments[1];
}
>>> toplama(3,5);
8
>>> function test(arguman1,arguman2){
return test.length;
}
>>> test()
2
Fonksiyonlar için method ve alt değişken tanımlamak
>>> var islemci = function(){
this.aciklama = "merhaba dünya!"
this.toplama = function()
{
return arguments[0]+arguments[1];
}
this.cikarma = function(sonuc)
{
return arguments[0]-arguments[1];
}
}
>>> var islem1 = new islemci();
>>> islem1.toplama(3,5);
8
>>> islem2.cikarma(3,5);
-2
>>> islemci.prototype.carpma = function(){
return arguments[0]*arguments[1];
}
>>> var islem2 = new islemci();
>>> islem2.carpma(3,5);
15
Fonksiyonlar, sadece faaliyet alanlarında erişilebilir durumda olan değerler alabilirler.Bu değerlerin tanıtıcısı, fonksiyon oluşturulurken argüman
tünelinde yazılır.Fakat gönderilen argümanlar için tanıtıcı belirtmek zorunlu değildir, tanıtıcı olsun veya olmasın, fonksiyon içindeki "arguments"
tanıtıcılı değişken argüman tünelindeki tüm verileri saklar.
Diziler, tek tanıtıcının altında veri parçalarını tanıtıcıya ihtiyaç kullanmadan saklamayı sağlayan veri türüdür, örnek olarak herbiri tek başına bir
değer olan birkaç elmayı tutan sepeti düşünelim.Sepeti tutan el, programımızı çalıştıran browser olmalı :) Fonksiyonlardan bir sonraki konu
başlığında dizileri daha detaylı inceleyeceğiz.
Az önce sözünü ettiğim "arguments" değeri, fonksiyonların argüman tünelinden gelen tüm değerleri sıralı olarak saklayan bir dizidir.Tanıtıcısı olsun
veya olmasın, browserlar gönderilen tüm argümanlara erişmemizi sağlar.Bir örnek;
Örnekte "argumanlar" adında, tek işlevi kendisine gelen argümanları geri döndürmek olan bir fonksiyon oluşturduk ve bu fonksiyona gönderdiğimiz
argümanların bize dizi tipinde geri döndüğünü gördük.Toplama örneğini "arguments" dizisinin elemanlarını seçip işlem yaptırarak yeniden ele
alalım:
Bu örnekte arguments dizisinin ilk iki elemanını, tanıtıcıları olan sıra numaralarıyla seçtik ve toplamlarını bulup geri döndürdük.Dizileri henüz iyice
anlamadığınızı düşünüyorsanız endişelenmeyin, dizileri ayrı bir başlıkta detaylı biçimde inceleyeceğiz.
Fonksiyonların içinde kaç argüman tanımlandığını bulmak içinse, fonksiyon tanıtıcısının alt değişkeni olan .length değeri kullanılır.Örnek olarak,
argüman tünelinde tanımlanan değişkenlerin sayısını gönderen bir fonksiyon yazalım:
ECMAScript'te, fonksiyonların her biri diğer dillerde rastladığımız "class"'lara benzer, alt değerler tanımlanabilir ve new operatörüyle klonlanabilir.
Alt değer tanımlamak için, fonksiyonun içindeki "this" değerine erişilir.Alt değerler fonksiyon bloğunun dışında da tanımlanabilir. Bir örnek;
islemci adında, toplama cikarma methodlarını içeren bir fonksiyon yarattık ve ardındaki satırda, islem1 tanıtıcısına yeni bir islemci objesini
atadık.Bu kez, az önce yazdığımız islemci objesinde, prototypeı kullanarak yeni bir alt method yaratalım;
prototype Klonlanabilir nesnelerin ortak etki alanına sahip olmasını sağlayan bir değerdir.Eğer prototypeı kullanmadan tanımlama yaparsak, alt
methodu olduğumuz objenin etki alanına yani içerdiği değerlere erişemeyiz.Buna bir örnek verelim:
4. >>> islemci.prototype.aciklamayiGoster1 = function(){
return this.aciklama;
}
>>> islemci.aciklamayiGoster2 = function(){
return this.aciklama;
}
>>> islemci.aciklamayiGoster1()
"merhaba dünya!"
>>> islemci.aciklamayiGoster2()
undefined
Dışarıdan Erişime Kapalı Özellikler
>>> function test(){
var _deger = "merhaba dünya!";
this.degeriGetir = function(){
return _deger;
}
}
>>> test1 = new test();
>>> test1._deger
undefined
>>> test1.degeriGetir()
"merhaba dünya!"
Apply
>>> var kisi = function(adsoyad,yas,dogumyeri){
this.adsoyad = adsoyad;
this.yas = yas;
this.dogumyeri = dogumyeri;
}
>>> var arda = new kisi("Arda Koçulu",17,"Kars");
>>> arda.dogumyeri
"Kars"
>>> var oyuncu = function(adsoyad,yas,dogumyeri,takim,skor){
this.takim = takim;
this.skor = skor;
kisi.apply(this,arguments);
}
>>> var kemal = new oyuncu("kemal akın",15,"antalya","maviler",3);
>>> var ege = new oyuncu("ege akın",10,"izmir","kırmızılar",2);
>>> kemal.takim
maviler
>>> ege.dogumyeri
izmir
Görevleri islemci objesine ait aciklama değerini döndürmek olan etki alanları farklı, iki tane fonksiyon tanımladık.İlk tanımladığımız fonksiyonu
deneyelim:
Gördüğünüz gibi, islemci nesnesine prototype köprüsünden erişti ve içerdiği değerleri aldı.Diğerini deneyelim:
Tanımlanmamış değer döndürdü çünkü etki alanı kendisiydi.sadece kendi içindeki ve window altındaki değerlere ulaşabilirdi.Elbette bu problem
çözümsüz değil, call ve apply methodları fonksiyonların etki alanını belirlememizi sağlar.
C Tabanlı programlama dillerindeki class yapılarında, methodların dışarından erişime açık olup olmadığı belirtilebilir.ECMAScript'in yeni
sürümündeki class yapıları da public/private alt method ve değerleri destekler.
Şu an kullandığımız sürümde de public/private özellikler oluşturulabiliyor, bunun için fonksiyon bloklarının etki alanlarından faydalanılır;
Yukaridaki örnekte test adında bir fonksiyon oluşturduk ve biri dışarıdan erişime kapalı, iki değer oluşturduk.
apply Javascript'in isviçre çakısıdır.Bu özellik sayesinde, fonksiyonlar birbirlerinin yapılarının üstüne inşa edilebilir ve bunun saymakla bitmez
faydalarından biri, modern object oriented dillerinin kalıtım özelliğini bize sağlamasıdır.Örneğin, kimlik bilgileri içeren "kişi" objesi üzerine, skor ve
benzeri bilgileri içeren "oyuncu" objesi oluşturalım:
Kişi objesini inceleyelim; bir fonksiyon oluşturduk ve argüman tünelinden gelen üç veriyi bu fonksiyona alt değer olarak atadık.Ardındaki satırda
"arda" değerini "new" operatörüyle yeni bir kişi olarak tanımladık.Kişi objesini oluşturduğumuza göre, oyuncu objesine de geçebiliriz:
Oyuncu adında bir nesne oluşturduk, argüman tünelinden beklediğimiz değerleri tanıtıcılarına tanımladıktan sonra, takim ve skor alt değerlerini
atadık.Ardından gelen satırda ise, kisi objesinin apply methodunu çalıştırdık ve "this","arguments" argümanlarını gönderdik. "this" argümanı, kişi
objesinin hangi fonksiyon tarafından çağrıldığını göndermek için kullanılır.arguments Argümanıysa, apply methoduyla çağrılan fonksiyonun
argüman tünelinden beklediği argümanları göndermemizi sağlar."arguments" değeri, oyuncu fonksiyonuna gelen değerleri içerdiğinden, "oyuncu"
5. Call
>>> (function(){
alert(arguments.slice); // undefined değer döner
})("merhaba","dünya");
>>> (function(){
alert(Array.prototype.slice.call(arguments,1) // dönen değer: ["dünya"]
})("merhaba","dünya");
Call ile kalıtım
>>> var kisi = function(adsoyad,yas,dogumyeri){
this.adsoyad = adsoyad;
this.yas = yas;
this.dogumyeri = dogumyeri;
}
>>> var oyuncu = function(adsoyad,yas,dogumyeri,takim,skor){
this.takim = takim;
this.skor = skor;
kisi.call(this,adsoyad,yas,dogumyeri);
}
>>> var kemal = new oyuncu("kemal akın",15,"antalya","maviler",3);
>>> var ege = new oyuncu("ege akın",10,"izmir","kırmızılar",2);
>>> kemal.takim
maviler
>>> ege.dogumyeri
izmir
Prototype
>>> var kisi = function(adsoyad,yas,dogumyeri){
this.adsoyad = adsoyad;
this.yas = yas;
this.dogumyeri = dogumyeri;
}
>>> kisi.prototype
Object: There are no properties to show for this object.
>>> kisi.prototype.meslek = null;
>>> kisi.prototype
fonksiyonuna gelen tüm argümanlar "kisi" fonksiyonuna gönderililir.
call fonksiyonu tıpkı apply gibi, fonksiyonları kendi belirlediğimiz etki alanı ve argümanlarla çalıştırmamızı sağlar.Bir problemin çözümünü
anlatarak örnek yapalım, javascript arguments dizisinin alt methodlarını kullanmamıza olanak tanımaz.Deneyelim;
Parantez blokları içindeki fonksiyonumuza iki metinsel değer gönderdik.Fonksiyondaysa, gelen argüman listesinin slice methodunu kontrol
ediyoruz ve tanımlanmamış olduğunu görüyoruz.
Şimdi bu problemin çözümünü inceleyelim:
slice Methodunun işlevi o kadar önemli değil, diziler konusunda inceliyoruz.Burada dikkat etmeniz gereken, prototipteki fonksiyon kaynağına
ulaşmamız ve bu fonksiyonu call methodu ile çağırmamız.call nesnesine gönderdiğimiz argümanlardan birincisi etki alanını belirliyor, diğeri ise
slice methodunun argüman tünelinden beklediği ilk değer. Gördüğünüz gibi, call methodu applyden farklı olarak argümanları topluca liste olarak
almıyor, ilk argümanı etki alanı değeri kabul edip diğer bütün argümanları çalıştırdığı fonksiyona aktarıyor.
Kalıtım ilişkileri kurmak için apply'den daha çok tercih edilen methoddur.Mantık olarak pek farklılık yok, istenen objeye "scope" ve argümanlar
gönderiliyor:
Örnekte gördüğünüz gibi, apply ile temel farklılık call methodunun argümanları serbest biçimde göndermemizi sağlaması.
Prototype'ı bir binanın iskeletine benzetebiliriz, hatta bu benzetmeye tahmin ediyorum birkaç yüz dökümanda daha rastlayabilirsiniz çünkü
prototype benzetmeden daha öte, fonksiyonların iskeletidir.
Prototype değerlerinin tipi objedir.Yani bir objeyi alıp, bir fonksiyonun iskeleti olarak kullanmak mümkündür.Tabii bunun tam tersi durum da
sözkonusu.
Fonksiyonların klonlanarak objeye dönüştürülmesini anlatırken bir detayı atlamıştık; objenin özellikleri fonksiyonun tanımlandığı blokta olmak
zorunda değil.Oluşturduğumuz fonksiyonun iskeletine ulaşabilir ve çeşitli eklemeler yapabiliriz.Şimdi adım adım bir fonksiyon yazalım ve konsolun
döndürdüğü değerleri yorumlayalım:
Örnekte kisi adında bir fonksiyon oluşturup içine adsoyad,yas,dogumyeri özelliklerini yazdık.Ardındaki satırda prototype'ı incelediğimizde, boş bir
objenin döndüğünü görüyoruz.Bu durumdan şunu çıkarmalıyız, iskeletin inşası prototype objesi dışında yapılamaz.Veya şöyle özetleyelim,
fonksiyonun içinde iskelet oluşturamayız.
Yukaridaki örnekte prototype objesinin altında bir alan açarak, kisi fonksiyonuna meslek adında bir özellik ekledik.
6. Object: (meslek = null)
>>> selcuk = new kisi("selçuk koçulu",48,"mardin");
>>> selcuk.meslek
null
>>> var kisi = function(adsoyad,yas,dogumyeri,meslek){
this.adsoyad = adsoyad;
this.yas = yas;
this.dogumyeri = dogumyeri;
this.meslek = meslek;
}
>>> fikretkizilok = new kisi("fikret kızılok","60","İstanbul","Müzisyen");
>>> fikretkizilok.meslek
"müzisyen"
>>> kargo.prototype.alan = null;
>>> kargo.prototype.gonderen = null;
>>> kargo.prototype.kargoicerigi = null;
>>> function kargo(alan,gonderen,kargoicerigi){
this.alan = alan;
this.gonderen = gonderen;
this.kargoicerigi = kargoicerigi;
}
>>> kargo.prototype.ucret
0
>>> var azerkoculu = new kisi("azer koçulu",20,"kaş","web geliştirici");
>>> var billgates = new kisi("bill gates",53,"seattle","işadamı");
>>> var yeniKargo = new kargo(azerkoculu,billgates,"mozilla stickers");
Prototype ve Browser Nesneleri
>>> String
String()
>>> String.prototype.replace
replace()
>>> "Merhaba Dünya".replace
replace()
>>> Number.prototype.topla = function(sayiDegeri){
return this+SayiDegeri
}
>>> (4).topla(8)
12
>>> 4.0.topla(8)
Bu örnekteyse selcuk adında bir obje oluşturduk ve meslek özelliğini sorguladık.Dönen sonucun null -bu bizim belirlediğimiz bir varsayılan
değerdi- olduğunu görüyoruz.
Buradaki problem, iskelete sonradan eklenen meslek özelliğini constructor'a nasıl dahil edeceğimiz.Bu iş için constructor'ın yeniden yazılması
kaçınılmazdır;
Bu örnekte dikkat etmemiz gereken, kisi fonksiyonunun eski iskeleti devralması.Peki bu durumda henüz tanımlanmamış fonksiyonların iskeleti
oluşturulabilir mi? Evet, oluşturulabilir.
Bunu denemek için yeni bir fonksiyon yazalım:
Görüldüğü gibi, undefined değeri olan bir tanıtıcı altında iskelet oluşturduk ve ardından bu tanıtıcıya fonksiyon değeri verdik.Son satırda ise,
tanıtıcı değer almadan oluşturduğumuz iskeletin çalışır durumda olduğunu onayladık.Biraz önce yazdığımız kisi nesnesinden de faydalanarak
kargo'nun kullanımına bir örnek verelim:
Javascript'in disable olmadığı durumları saymazsak, browserlar her HTML belgesinde javascript komutlarının çalışmasını sağlayan bir zemin
oluşturur.String,Number,Function,Array,Object nesneleri browser sözettiğimiz çekirdekte yer alan nesnelerden birkaçıdır.
Yazdığımız her sayı Number objesinden, her yazı String objesinden türer.Ve tahmin edeceğiniz gibi, bu değerlerin methodları, çekirdekteki
nesnelere bağlıdır.String nesnesinin methodlarından birini deneyelim:
String nesnesinin prototype objesindeki replace fonksiyonuna erişip kontrol ettik.Şimdi de oluşturacağımız string değerinde replace methodunun
kullanımını inceleyelim:
ECMAScript standartını kullanan dillerden biri de Actionscript'tir.Bu dil de String,Number gibi objeler oluşturur fakat geliştiricinin bu nesneleri
değiştirmesi kısıtlanmıştır. Neyse ki javascript için böyle bir durum söz konusu değil, browser nesnelerini dilediğimiz gibi değiştirebilmekteyiz.Örnek
olarak Number objesine bir method ekleyelim:
Number nesnesinin iskeletine "topla" adında bir fonksiyon ekledik.Böylece, tüm sayılar için pratik bir toplama methodu yaratmış olduk, deneyelim:
7. 12
>>> Object.prototype.deneme = "foo bar"
>>> "".deneme
"foo bar"
Caller
>>> var merhaba = function(){
return merhaba.caller;
}
>>> merhaba()
null
>>> (function(){ return merhaba() })()
(function(){ return merhaba() })()
>>> var merhaba = function(){
if(merhaba.caller!=null)
return "Bu fonksiyona başka bir fonksiyonun içinden erişemezsiniz."
return "Merhaba!"
Internet Explorer ve eval() İstisnası
Bölüm Sonu Pratikleri
SORULAR
CEVAPLAR
var fonksiyon = new Function(argüman1,argüman2,......,fonksiyonKodları);
var sayfaBasligi = new Function("return '"+document.title+"'");
var deneme = function(){ alert(this.adres); }
deneme(); // undefined
deneme.call({ "adres":"google.com" }); // google.com
Aklınıza şu soru gelmiş olmalı: Peki ondalık hanelerin nokta işaretleriyle methodlarınki karışmaz mı? Evet karışır.Bunun için sayılar parantez içine
alınır, veya ondalık hanesinden sonra method yazılır.
Örnekte gördüğünüz gibi, Number sınıfından türeyen sayı değerlerinin altında topla methodu kendiliğinden gelmektedir.
Küçük bir ipucu: prototype Obje tipindedir yani Object sınıfından türemiştir.Şimdi browser'ımızı heyecanlandıracak birkaç deneme yapalım:
Örnekte, Object sınıfının iskeletine bir ekleme yaptık ve böylece Object sıfından türemiş olan tüm iskeletlere değişikliği uyguladık.Yani, deneme
fonksiyonu tüm iskeletlere eklendi.Bir sonraki satırda oluşturduğumuz string değeri kontrol ettik ve bu durumu doğruladık.
Protype'lar hakkında genel bilgi sahibi oldunuz.Obje türlerini inceledikten sonra prototype'lara tekrar dönüp deney yapmanızda fayda var.
Fonksiyonların nasıl çağrıldığını anlamak için, alt özellikleri olan "caller" kontrol edilir, eğer herhangi bir fonksiyon içinde çağrılmadıysa, "null"
değerini döndürür.Bu özellik "fonksiyonAdı.caller" biçiminde kullanılır:
Örnekte, "merhaba" adında, kendisini çağıran fonksiyonu döndüren bir fonksiyon oluşturduk.Global blokta çağırdığımız satırda "null" değer
dönerken, diğerinde fonksiyonun kendisi döndü.
Örnek olarak, yazdığımız fonksiyonun başka bir fonksiyon içinden çağrılmasını engelleyebiliriz;
Dizi konusu gibi, ileride detaylıca inceleyeceğimiz konulardan biri de koşullar.Yukarıdaki örneğin ilk iki satırında, "merhaba.caller" değerini kontrol
ettik ve eğer "null" değilse, yani bir başka fonksiyonun içinden çağrı yapıldıysa, "Merhaba" yerine uyarı metni döndürdük."return" komutu verildikten
sonra yorumcunun fonksiyondan çıktığını hatırlayalım.
"Caller" Internet Explorer, Mozilla gibi popüler tarayıcıların desteklediği, aslında standart dışı bir özelliktir.Fakat Internet Explorer "eval()" komut
bloğunda çalıştırılan fonksiyonlar için de caller değerini "null" döndürmektedir.Kontroller yapılırken bu durumu dikkate almak gerekir.
Soru 1) Dinamik fonksiyon yazımına örnek vermek için, sayfa başlığını statik string olarak döndüren "sayfaBasligi" adında fonksiyon yazınız.
Soru 2)Javascript yazarken sıkça karşılaşılan sorunlardan biri, çalıştırılan fonksiyonların istenen scope'a sahip olmamasıdır.Bu tür problemlerin
çözümüne örnek vermek için, herhangi bir fonksiyonun scope değerini herhangi bir objeyle değiştiriniz.
Soru 3) Önceki sorudan devam.Scope problemlerinin çözümünü daha pratik hale getirecek "curry" adında bir fonksiyon methodu yazınız.
Cevap 1) Fonksiyonlar Function sınıfından türer.Klasik yazılışın yanında new operatörüyle Function sınıfından fonksiyon oluşturulabilir;
Buna göre sorunun cevabı;
Cevap 2) Bu problem hakkında detaylı bilgiyi call ve apply başlıklarında bulabilirsiniz.Sorunun yanıtı ise şöyle:
Deneme adında bir fonksiyon oluşturduk ve ikinci satırda çalıştırdık.Fonksiyonumuz çalıştığında, kendisine ait "adres" adında bir methodu aradı ve
8. >>> var deneme = {
kontrol: false
}
>>> deneme.kontrol
false
>>>var deneme = {
kontrol: true
};
>>>var kontrolDegeri = function(){ return this.kontrol; };
kontrolDegeri(); // undefined döner
kontrolDegeri.call(deneme); // "true" döner
>>> var kontrolDegeri = kontrolDegeri.curry(deneme);
>>> kontrolDegeri(); // true değeri döndü
>>> Function.prototype.curry = function(scope){
var fn = this;
var scope = scope||window;
return function(){
fn.apply(scope,arguments);
}
}
Diziler: array
var tekSayi = [1,'Bir',3,'Üç',5,'Beş']
>>> tekSayi[1];
'Bir'
tekSayi = new Array("Bir","İki","Üç");
böyle bir method tanımlanmadığından undefined değer döndü.Üçüncü satırda ise deneme fonksiyonunun call methoduna bir obje
gönderdik.Deneme fonksiyonu bu kez çalıştığında kendisinin etki alanını gönderdiğimiz
Bu problemin nasıl aşılacağını call ve apply başlıklarında detaylarıyla anlattım, şimdiyse bu işi oldukça pratik bir hale getirelim. Örneğin, herhangi
bir fonksiyonu şu biçimde çağıralım ve istediğimiz scope'u uygulayalım:
kontrossl adında bir boolean içeren deneme objesi oluşturduk, şimdi bu objeye iki ayrı yolla erişelim:
Kontrol değerini ilk çağırışımızda bize değer dönmedi ancak ikinci çağırma biçiminde istediğimiz değer döndü.Burada call methoduna scope değeri
olarak deneme objesini gönderdik ve böylece fonksiyonun içindeki this değeri, deneme objesine referanslandı.İlk satırda ise fonksiyonun içeriği
scope olarak window objesine eriştiğinden, istediğimiz değer dönmedi.
Cevap 3) Bir veri türüne method atamak için, o veri türünün constructor'ı üzerinde işlem yapmak gerekir.Daha ayrıntılı bilgi almak için, prototype
başlığına dönün.
Soruda bizden isteneni daha açık hale getirelim; her fonksiyonun "curry" adında bir methodu olacak ve biz bu methoda istediğimiz scope'u
gönderdiğimizde, bize yeni bir fonksiyon değeri gönderecek.Elde ettiğimiz yeni fonksiyonu dilediğimiz gibi çalıştırabileceğiz, yani fonksiyonumuz
apply veya call işlemlerindeki gibi, scope gönderilince hemen çalışmayacak.Önce örnek kullanımı inceleyin:
Bu kezcurry methodunu kullanarak, deneme objesini kontrolDegerinin scope'u olarak belirledik ve yeni bir fonksiyon değeri elde ettik.Eğer
kontrolDegeri ve deneme objesinin nerede oluşturduğumu kaçırdıysanız, ikinci sorunun çözümüne gözatın.
curry Methodunun yazımında öncelikle dikkat etmemiz gereken, bir fonksiyon değeri döndürecek olmamız, bir diğer önemli unsursa, argümanları
da kullanacak olmamız.call ve apply başlıklarında, argümanların nasıl kullanıldığını anlatmıştım, tekrar gözatabilirsiniz.Yazmaya başlayalım:
Gördüğünüz gibi pek karmaşık bir çözüm olmadı.İlk satırda, fn adında bir değer tanımladık bunun sebebi, geri döndürdüğümüz fonksiyon değerinin
içinden, üst fonksiyona erişemeyişimiz.Ancak üst fonksiyon bloğunda tanımladığımız değerler, birbirine erişebilir.Bu yüzden, scope değerini de
tekrar tanımladık.Genellikle mantıksal sorgulamalarda kullandığımız "veya" ifadesinin görevi ise, argüman olarak gelen scope değeri null,false
veya undefined olduğunda, window değerini döndürmektir.Daha sonraki satırda ise, bir fonksiyon değeri döndürüyoruz.Yeni fonksiyonun içeriğine
baktığımızda bu kez call değil apply kullandığımızı görürsünüz.Bunun sebebi, call methodunun argümanları array tipinde değil, tek tek
alması.apply ise bunun tam tersine, ilk argümandan sonra bir argümanları içeren dizi değeri bekler.Gönderdiğimiz arguments değeri, yeni
fonksiyona gelen argümanları içeren dizi değeridir.Bunun hakkında daha fazla bilgi istiyorsanız, argümanlar başlığına dönün.
İstenen veri parçalarını tür ayrımı yapmadan bir araya getirip gruplayan veri türüdür.ECMAScript dizi elemanlarının tanıtıcılarını sıra numarası
olarak tanımlar.Değer atama işlemi köşeli parantezler içinde dizi elemanlarını virgülle ayırarak yapılır:
Örnekte integer ve string türündeki verilerle bir dizi oluşturduk.Fakat istenirse, bir dizi elemanının tipi herhangi bir veri türü olabilir, örneğin number,
boolean, function, object veya yine array türünde bir dizi elemanı oluşturabiliriz.
Program içinde diziye erişmek istendiğinde, dizi elemanlarının anahtarlarını kullanmamız gerekir.Burada anahtar, dizi elemanının sıra numarasıdır
ve sıra numaraları sıfırdan başlar, yani son dizi elemanının sıra numarası dizi uzunluğundan bir eksiktir.Örnek olarak, az evvel oluşturduğumuz
tekSayi dizisinin ikinci elemanına erişelim:
Pek çok kaynakta dizilerin şu biçimde tanımlandığına rastlayabilirsiniz:
9. var islem = [
function(sayi0,sayi1){
return sayi0+sayi1;
},
function(sayi0,sayi1){
return sayi0-sayi1;
}
]
>>> islem[0](4,3)
7
>>> islem[1](4,3)
1
concat
>>> ["deneme"].concat(["merhaba"],["dünya"])
["deneme","merhaba","dünya"]
join
>>> ["merhaba","dünya"].join("#")
"merhaba#dünya"
>>> ["merhaba","dünya"].join("!")
"merhaba!dünya"
length
>>> var deneme = ["merhaba","dünya"]
>>> deneme.length;
2
pop
>>> var deneme = ["merhaba","dünya"]
>>> deneme.pop();
"dünya"
>>> deneme
["merhaba"]
push
>>> var deneme = []
>>> deneme.push("merhaba","dünya");
2
>>> deneme
["merhaba","dünya"]
Concat yerine Push methodunun kullanımı
Fakat görüldüğü gibi bu pratik bir tanımlama biçimi değildir. Az evvel herhangi bir türde veri tutulabildiğine değinmiştik, bu konuda bir örnek
hazırlamak için, fonksiyon bilgimizi de kullanarak toplama ve çıkarma yapan bir dizi oluşturalım:
Oluşturduğumuz dizi birbirinden virgülle ayrılmış iki ayrı fonksiyondan oluşuyor, birinci dizi elemanı toplama işlemi yaparken diğeriyse çıkarma
işlemi yapıyor.Şimdi bu dizinin elemanlarına tek tek erişip işlem yaptıralım:
Diziler, Array sınıfından türediğinden ötürü, her dizi aynı zamanda alt method ve değerleri olan bir objedir.Ve doğal olarak, dizi objeleri Array
iskeletini taşır ve bu iskelete serbestçe ekleme/çıkarma yapılabilir.Bu konuda daha detaylı bilgi ve örnekler için fonksiyonlar konusundaki prototype
altbaşlığını inceleyin.
Dizi değerlerin mevcut alt methodlarını inceleyelim:
İki veya daha fazla diziyi birleştirmek için kullanılır, örnek:
concat browser'ın fazladan bir dizi daha oluşturmasına neden olduğundan pek tercih edilen sağlıklı bir method değildir.Yerine daha kullanışlı olan
"push" methodu kullanılilir.Birkaç başlık sonra push methodunu inceleyeceğiz.
Verilen ayracı kullanarak diziyi string değere çevirir.Örnek,
Dizinin uzunluğunu, yani ne kadar dizi elemanı tuttuğunu veren değer.Örnek;
Dizinin son elemanını siler ve sildiği değeri döndürür.
Argüman tünelinden gelen değerleri dizinin sonuna ekleyen method.Geriye dizinin yeni uzunluğunu döndürür.
Push fonksiyonunu concat yerine kullanmak için, fonksiyonların apply methodundan ve prototype objesinden faydalanılır.Bu iki konuda detaylı
bilgiyi fonksiyonlar başlığında bulabilirsiniz.Gelelim örneğe;
10. >>> var dizi1 = [1,2];
>>> var dizi2 = [3,4];
>>> var dizi3 = [5,6];
>>> var dizi4 = [7,8];
>>> dizi1.concat(dizi2);
[1,2,3,4]
>>> Array.prototype.push.apply(dizi3,dizi4);
4
>>> dizi3
[5,6,7,8]
slice
>>> [3,6,9,12].slice(1,3)
[6, 9]
>>> [3,6,9,12].slice(1,4)
[6, 9, 12]
>>> [3,6,9,12].slice(0,2)
[3, 6]
Bölüm Sonu Pratikleri
>>> var a = [3,2,1];
>>> var b = a;
>>> b
[3, 2, 1]
>>> b.push(0);
4
>>> b
[3, 2, 1, 0]
>>> a
[3, 2, 1, 0]
>>> var deneme = function(){}
>>> deneme.prototype.dizi = [];
[]
>>> var nesne1 = new deneme();
>>> var nesne2 = new deneme();
>>> nesne1.dizi.push(1);
1
>>> nesne1.dizi
[1]
>>> nesne2.dizi
[1]
Array.prototype.clone = function(){
var gecici = [];
for(var i=0; i<this.length; i++){
gecici.push(
this[i] instanceof Array? this[i].clone():this[i]
);
}
return gecici;
Örnekte concat methodunun kullanımını hatırladık ve ardından apply methodunu çağırarak dizi3 ile dizi4 ü birleştirdik.
Dizi değerlerinin içinden istenen index aralıklarını çağırmayı sağlar;
ECMAScript standartına göre, diziler ve nesneler farklı değişkenlere aktarılamaz, referanslanır.Bunu daha iyi anlamak için bir örnek yapalım:
Örnekte, b değerine ilk oluşturduğumuz a değerini atadığımızda, iki değer birbirine referanslandı.Bunu anlamak için b dizisine yeni bir sayı ekledik,
a dizisini kontrol ettiğimizde aynı sayının a'ya da eklendiğini gördük.Aslında b'ye eklendiğimiz a'ya eklenmedi, daha doğrusu biz hem a'ya hem b'ye
ekleme yaptık.
Bu özelliğin açtığı problemlerle ilgili bir örnek yapmak için dizi tipinde alt değeri olan bir sınıf tanımlayalım:
Örnekte gördüğünüz gibi, deneme iskeletinden türeyen tüm objelerin dizi tipindeki alt değeri birbirine referanslı.Biri değişince diğeri de
değişmekte.Şimdi sorulara geçelim:
SORULAR
Soru 1) Dizilerin klonlanmasını sağlayan, dizi.clone() şeklinde çalıştırılabilen bir method yazın.Dizilerin içiçe olabileğini dikkate alın.
Soru 2) Birinci sorunun cevabını, fonksiyonların iskeletinde yaşanan referans probleminin çözümü için uygulayın.
CEVAPLAR
Cevap 1) Bu problemin çözümü için bu dökümanda bahsetmediğim döngüleri ve kontrol ifadelerini biliyor olmalısınız.Sınıfların iskeletine method
ekleme işlemi hakkında bilgi almak için Fonksiyonlar konusundaki prototype başlığına dönün. Problemin cevabına geçelim:
11. }
this[i] instanceof Array? this[i].clone():this[i]
>>> var deneme = function(){
this.dizi = this.dizi.clone();
}
Nesneler: object
>>> var merhaba = { ingilizce:"hello", ispanyolca:"holla" }
>>> merhaba.ingilizce
hello
>>> merhaba["ispanyolca"]
holla
>>> var meslekler = { "azer koçulu":"öğrenci", "nuray koçulu":"öğretmen" };
>>> meslekler.azer koçulu // hatalı tanıtıcı yazdık.
SyntaxError: missing ; before statement
>>> meslekler["azer koçulu"]
öğrenci
>>> var meslekler = { "azer koçulu":"öğrenci", "nuray koçulu":"öğretmen" };
>>> meslekler["arda koçulu"] = "öğrenci"
>>> var islem = {
topla: function(sayi0,sayi1){
return sayi0+sayi1;
},
cikar: function(sayi0,sayi1){
return sayi0-sayi1;
}
}
>>> islem.topla(2,3);
5
>>> islem.cikar(2,3);
-1
>>> islem.cikar(islem.topla(2,3),1);
4
>>> var islemci = function(sayi0){
return {
topla: function(sayi1){
Örnekte, gecici adında yeni bir dizi oluşturduk ve dizi elemanlarını tek tek bu yeni diziye ekledik.Ve yeni diziyi geri döndürdük.Bu örnekteki en
önemli satır, push fonksiyonuna veri gönderirken yaptığımız kontrol:
Eğer dizinin elemanı da bir diziyse, onu da klonlamamız gerekir.Bunun için sıradaki dizi değerinin Array sınıfından türeyip türemediğini instanceof
operatörünü kullanarak kontrol ettik.
Cevap 2) Eğer iskelete dışarıdan dizi değeri eklediysek, fonksiyonun constructor'ında bu değeri klonlamamız gerekir.
Objeler, tıpkı diziler gibi, istenen veri parçalarını gruplayan veri türüdür fakat dizi elemanlarının aksine, nesnelerdeki elemanlar için tanıtıcı
belirlenir.
Dizilerdeki köşeli parantezlerin yerini süslü parantezler alır.Nesne elemanları birbirlerinden yine virgülle ayrılırlar.Fakat bu kez her veri parçası için
bir tanıtıcı belirlenir, bu işlem için "var" ifadesi ve eşit işareti kullanılmaz, tanıtıcı yazılıp hemen ardında ":" kullanılır. Örneğin,
Nesnelerin elemanları birer method olarak kabul edilir, dizilerde görülen çağırma işlemi dışında, diğer programlama dillerindeki sınıf yapılarından
alışık olduğumuz method biçimindeki çağırma işlemi de yapılabilir, her iki biçimde de çağırma işlemi yapalım:
Method biçimindeki çağırma işleminde tanıtıcının kullanım şekli özel karakter yazımına ve satıriçi dinamik kullanıma uygun olmaması, dizi
biçimindeki tanımlamaNes şeklinin önemini artırır;
Nesne tanımlandıktan sonra yeni bir eleman ekleme-çıkarma işlemi yapmak için dizilerdeki push ve pop fonksiyonları yerine, yine dizilerden alışık
olduğumuz tanımlama biçimi kullanılır:
Bu veri tipinin esnek yapısı sayesinde, ECMAscript'in OOP eksikliği tamamlanır.Dizilerdeki basit işlem dizisini, nesneleri kullanarak tekrar yazalım:
Yaptığımız örnekte, "islem" adında bir nesnenin içinde, fonksiyon tipinde "topla" ve "cikar" adlarını taşıyan iki method oluşturduk, ve birkaç değerle
test ettik.
Örnekteki kodlama türünün, işlem yaptırdığımız değerleri gruplama dışında özel bir işlevi yok.Peki diğer programlama dillerinde alışık olduğumuz
"new" operatörüyle oluşturulan (klonlanan da denilebilir) sınıflar oluşturulamaz mı? Elbette oluşturulur, örnekten ilerleyelim:
12. return sayi0+sayi1;
},
cikar: function(sayi1){
return sayi0-sayi1;
}
}
}
>>> var islem1 = new islemci(5);
>>> islem1.topla(3); // 5+3 = 8
8
>>> islem1.cikar(3); // 5-3 = 8
2
Bölüm Sonu Pratikleri
Object.Clone = function(){
var gecici = [];
for(var i=0; i<this.length; i++){
gecici.push(
this[i] instanceof Array? this[i].clone():(
typeof this[i]=="object"?
Object.Clone(this[i]):
this[i]
)
);
}
return gecici;
}
typeof this[i]=="object"?Object.Clone(this[i]):this[i]
function deneme(){
return ({
"Init": function(){
alert("Init fonksiyonundan merhaba!");
return this;
}
}).Init()
}
İleri Seviye OOP Teknikleri
Uyguladığımız son iki örnekteki farka dikkat edelim, ilk örnekte işlem yapan fonksiyon tipindeki verileri saklayan bir obje vardı, ikinci örnekteyse,
birinci örnekte saklanan objeyi "return" operatörüyle geriye döndüren bir fonksiyon var.
Örnekteki "islem1", 'islemci`'nin argüman tünelinden aldığı "5" değeri için döndürdüğü "topla" ve "cikar" fonksiyonundan oluşan nesne değerini
aldı.Ardındaki satırlarda bu fonksiyonları test ettik.
Diziler için geçerli olan referans problemi objeler için de geçerlidir.İlk soru aynı konudan geliyor:
SORULAR
1) Object fonksiyonunun altında, argüman tünelinden aldığı objeleri klonlayan Class adında bir method yaratın.Eğer objenin içindeki dizi değerleri
varsa, onları da klonlamayı unutmayın.Zorlandığınızda diziler konusundaki çözümden faydalanabilirsiniz.
2) Obje döndüren bir fonksiyon yaratın.Fakat bu objenin Init adında bir methodu olsun ve fonksiyonun içinde döndürme işleminden önce çalışsın.
CEVAPLAR
1)
Diziler başlığında kullandığımız klonlama fonksiyona bir kontrol daha ekledik:
Burada aslında değeri instanceof ile Obje sınıfından türeyip türemediğini de kontrol edebilirdik.Fakat browser bu kontrolde fonksiyonlar için de
pozitif değer döndürecektir.
2) Bu problemin çözümü aslında oldukça basittir, objeyi önce tanımlar sonra return operatörüyle geri döndürürüz.Fakat bu çözüm düşünmeyi pek
gerektirmez, biraz daha düşünüp daha iyi yöntem bulmalıyız.Bu tip kolay problemleri nasıl daha pratik şekilde çözebileceğimizi, tekniğimizi
ilerletmek için önemsemeliyiz.Çözüme geçelim:
Parantez bloklarını kullanarak biraz daha iyi bir çözüm kullandık.Buradaki çözümün özü Init fonksiyonunun içinde bulunduğu objeyi döndürmesi.
Fonksiyonları, dizileri ve objeleri pekiştirdiğimize göre, İleri OOP Teknikleri konusuna geçebiliriz.
bu başlık altındaki kod örneklerini ingilizce hazırladım.bunun sebebi kod standartlarını daha iyi anlamanızı sağlamak
Bu başlığa gelmeden önce, klasik obje yapılarını ve yeni popülerleşen obje tekniklerini pratikleştirdik.Neydi bu teknikler, birincisi fonksiyonlar
başlığında gördüğümüz sınıf oluşturma tekniği.İkincisi, objeler başlığında incelediğimiz, çok daha pratik olan sınıf oluşturma tekniği.Fonksiyonlar
13. function deneme(){
this.özellik1 = değer;
}
var yeni = new deneme();
function deneme(){
}
deneme.prototype.özellik1 = değer;
var yeni = new deneme();
function deneme(){
}
deneme.prototype = {
"özellik1":değer;
}
var yeni = new deneme();
var deneme = {
"özellik1":değer;
}
var yeni = Object.Clone(deneme);
function deneme(){
return {
"özellik1":değer
}
}
function account(){
}
account.prototype = {
"_balance":0, "_limit":0, "_name":"",
"getBalance":function(){
return this._balance;
},
"setBalance":function(value){
this._balance = value;
},
"getLimit":function(){
return this._limit;
},
"setLimit":function(value){
this._limit = value;
},
"getName":function(){
return this._name;
},
"setName":function(value){
this._name = value;
},
"SendMoney": function(value){
this.setBalance(this.getBalance()-value);
},
"Invest":function(value){
this.setBalance(this.getBalance()+value);
}
}
başlığındaki yapılara tekrar gözatalım:
Objeler başlığından çıkaracağımız yapılarsa şunlar:
Her iki tekniğin de profesyonel web projelerinin pek çoğunda kullanıldığı görülür, ancak kod standartına göre yazım stilleri biraz daha değişim
gösterecektir.Örnek olarak şu an çalıştığım şirketin kod standartına göre bir sınıf oluşturalım.
Obje: Banka Hesabı Değerler: ad soyad, bakiye, borç limiti İşlemler: Para Gönder, Para Yatır
Bu yazım biçimini anlamaya çalışalım, neden değişken adlarının önünde underscore işareti var? Neden her değişken için get/set methodları
yazılıyor?
Underscore koymamızın nedeni browser'ın reserveli kelimeleriyle çakışma olmamasını sağlamak.Örneğin "class" adında bir değer oluşturmamız
gerekirse, webkit ve internet explorer yazdığımız kodu durduracaktır.Bunun için underscore ile işareti kullanırız.
Peki, bir değeri isterken, veya ayarlarken, başka bir işlem yapmamız gerekiyorsa ne yaparız.Veya esas değeri, istenen şekle göre süzerek
vermemiz gerekiyorsa? Bu tip durumlarda standart bozulur, veya kodun akışı değişir.Böyle durumlar için get/set özellikleri yazmak daha doğru
olacaktır.Peki, oluşturduğumuz bu objede get ve set fonksiyonları içinde süzme vb. işlemler yapılıyor mu? Hayır.Bu unsuru aklımızda tutalım,
birazdan tekrar düşüneceğiz.
14. var azer = new account();
azer.environment.setName("Azer Koçulu");
azer.environment.setBalance(1000);
azer.environment.setLimit(2000);
// işlem yapan fonksiyonları kullanalım:
azer.sendMoney(500);
Bölüm Sonu Pratiği
var account = new Interface;
account.body = {
"Invest":function(){
},
"SendMoney":function(){
}
}
account.environment = {
"_balance", "_limit", "_name"
}
account = account.build();
var interface = function(){
this.constants = {};
this.environment = {};
this.events = {};
this.body = {};
}
interface.prototype = {
"constant":{},
"constructor":function(){},
"environment":{},
"event":{},
"body":{},
"extend":function(OBJECT){
var body = Object.Clone(OBJECT.prototype);
Object.Concat(this.body,body);
Object.Concat(this.constants,body.constants);
Object.Concat(this.environment,body.environment);
Object.Concat(this.event,body.event);
},
"build":function(){
var link = this;
var fn = function(){
this.constants = Object.Clone(this.constants);
this.environment = Object.Clone(this.environment);
this.environment._parent_ = this;
this.event._parent_ = this;
link.constructor.apply(this,arguments);
};
Son iki satırda işlem yapan fonksiyonları, baş harfleri büyük şekilde yazdık.Çünkü ortam değerlerinden ayrılmaları gerekiyordu.
Elimizde iki önemli unsur var: birincisi önemsiz yere get ve set kullanmamak.Yani gerektiğinde yazmalıyız.Fakat yazmasak ta standart
bozulmamalı, makine kendisi bizim yerimize rutin işlemleri yerine getirmeli.Diğer husus, işlem yapan fonksiyonları ortam değerlerinden ayırmak.Bu
iki unsuru toparlarsak nasıl bir obje yapısına ihtiyacımız olduğuna karar verelim.Genel kullanım şekli şöyle olsun:
Örnekte gördüğünüz gibi, ortam değişkenlerini alt objeye yerleştirerek işlem yapan fonksiyonlardan arındırıp biraz daha düzenledik.
Bu kullanım örneğinden ilerlemek istediğimizde karşımıza çıkacak ilk sorun, environment objelerinin referanslanarak birbirine bağlı hale
gelmesidir.Sadece environment objesini düşünmeyelim, normalde prototype üzerinden sınıf oluşturmaya çalıştığımızda, dizi ve obje türü değerlerin
hepsi birbirine referanslanacak ve programımızı bozacaktır.
Bu problemleri aşmak için istediğimiz gibi sınıf oluşturmamızı sağlayan bir arabirim gereklidir.
Her sınıfın Constant,Environment,Event adında alt objeleri olmalı.Program yazarken, sabitleri, ortam değişkenleri ve event yakalayıcıları bu şekilde
ayırmalıyız.Ve tabii, gerek olmadığında get/set yazmamalıyız, bizim yazmadığımız get ve set methodlarını kod standartının bozulmaması için
program bizim yerimize oluşturmalı.En önemlisi de, yapacağımız arabirim referans problemini otomatik olarak çözmeli.Arabirimin örnek kullanımını
inceleyin:
Bu örneğe ek olarak, extend ve constructor adlı iki methoda ihtiyacımız var.extend, oluşturacağımız sınıf başka bir sınıfı kapsıyorsa kullanacağımız
method olacak.consturctor ise, oluşturacağımız sınıfın constructor'ı olacak.Bu noktada obje referans problemini constructor'da çözdüğümüzü
hatırlamalısınız.
Okuduğunuz döküman bu sınıfı yazabilmenizi sağlamaya çalıştı.Bu pratiği yaparken kod standartınızı geliştireceğinize inanıyorum, umarım
döküman faydalı olmuştur. Sorunun cevabını mı merak ediyorsunuz :) Interface adını verdiğim sınıfı, hazırladığım Pi adlı javascript kütüphanesi
için yapmıştım.İşte kodları:
15. for(var item in this.environment){
if(item.substring(0,1)!="_")continue;
var name = item, title = name.substring(1,2).toUpperCase()+name.substring(
if(Boolean(this.environment["get"+title])==false)
this.environment["get"+title] = new Function("return this."+name);
if(Boolean(this.environment["set"+title])==false)
this.environment["set"+title] = new Function("VALUE","this."+name+
}
this.body.constants = this.constants;
this.body.environment = this.environment;
this.body.event = this.event;
fn.prototype = this.body;
return fn;
}
};
Sizin için faydalı bir döküman olduğunu umut ediyorum.Sabrınızın ve gayretinizin karşılığını almanızı dilerim.
Azer Koçulu