Aklımda Kalası Kelimeler

* давайте работать вместе
* Zarf ve Mazruf, Zerafet(xHoyratlık) ile aynı kökten(za-ra-fe) gelir
* Bedesten
* Suç subuta ermiştir - Suç sabit olmuştur
Javascript etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
Javascript etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

14 Mart 2017 Salı

Typescript notlarım

Functions are first class objects in javascript

JS de fonksiyonlar birinci sınıf nesnelerdir (Functions are first class objects in javascript). Yani javascript fonksiyonlar, nesnenin özel tipli halleridir. Bir fonksiyon köken itibarıyla nesnedir aynı zamanda.
Fonksiyonlar sadece bir metot değil, aynı zamanda veri tutan, nesne yaratılan, statik metot ve verileri olan sınıflardır.
function Deneme(parametreVeri){ 
  
  this.NesneVerisi = parametreVeri;

  this.NesneyeBagliMetot = function() {
    console.log("Nesne tarafından çağırılabilir");
  }

}

Deneme.StatikVeri = "Sadece fonksiyon adından erişilebilir";

Deneme.StatikMetot = function() { 
  console.log("Sadece fonksiyon üstünden çağırılabilen metot");
};

Deneme.prototype.NesneyeBagliMetot2 = function() {
  // Tüm nesneler, Deneme fonksiyonunun prototype özelliğine
  // erişebildiği için bu tip metot ve özellikler bir kez yaratılır
  // ve Deneme sınıfından yaratılmış tüm nesneler tarafından kullanılır
  console.log("this ile nesneye erişiriz: " + this.NesneVerisi);
};

Deneme.prototype.NesneyeBagliVeri2 = "Bu şekilde de nesneye veri eklenebilir";

console.dir(Deneme)

7 Ocak 2016 Perşembe

Dosyayı, sunucudaki adından farklı kaydetmek

Amacım DWelle RSS'indeki Almanca mp3 eğitim dosyalarını eğitimin başlığıyla kaydetmek. Elimizdekiler:
Öncelikle mp3 dosyalarına tıkladığımızda kaydetmek için karşımıza gelecek dosya adı şöyle gözüküyor:
Biz ise kaydederken adının title alanına ".mp3" eklenmiş halini Ders 10 - Bir oda rezervasyonu yaptırmak istiyorum.mp3 istiyoruz. Eğer a etiketi içinde href özelliği bir adresi değilde doğrudan dosyayı içeriyor olsaydı kaydetmek için istediğimiz dosya adını download özelliğine yazmamız ve tıklamamız yeterliydi. <a download="logo.png" href="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7">Download transparent png</a> RSS içindeki bilgileri çekmek için XPath kullanabilirsiniz. Bunu da Chrome browser ile yapabilirsiniz. Güzel bir anlatım için aşağıdaki resimlere bakabilirsiniz:
Kaynak: http://yizeng.me/2014/03/23/evaluate-and-validate-xpath-css-selectors-in-chrome-developer-tools/ Bizim a etiketlerimiz şöyle olacak:
<a href='http://radio-download.dw.de/Events/podcasts/tur/3803_DKpodcast_dwn1_tur/DWN_Tuerkisch_Serie1_Lektion01-podcast-3803-293588.mp3' data-saveas='Ders 01 - Bu bir şarkı.mp3'>Ders 01 - Bu bir şarkı</a>
data-saveas içinde yeni dosya adı, href içinde ise sunucudaki dosyanın adresini tutacağız. Haydi başlayalım ! Aşağıdaki kodu Chrom'un Console sekmesinde çalıştırdığınızda xpath ile sogulamalar için hızlı ve manipule edebileceğiniz bir fonksiyonu yüklemiş olursunuz.
var xpath = function(xpathToExecute){
  var result = [];
  var nodesSnapshot = document.evaluate(xpathToExecute, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null );
  for ( var i=0 ; i < nodesSnapshot.snapshotLength; i++ ){
    result.push( nodesSnapshot.snapshotItem(i) );
  }
  return result;
}
Bu kod ile indirilecek a etiketlerini oluşturalım
var aDizi = [], 
    arrTitle= xpath("//item/title/text()"), // Tüm title içindekilerini alalım. Bunlar bizim mp3 dosyamızı kaydederken kullanacağımız dosya adlarımız olacak
    arrUrl=xpath("//item/enclosure/@url/text()");// Tüm mp3 dosyalarının URL adreslerini alalım. Önce stream olarak alıp blob olarak saklayacak ve tıkladığımız a etiketlerinden diskimize kaydedeceğimiz akışlar

arrTitle.forEach(function(_title, _idx){
  console.log(_idx)
  console.log(arrUrl[_idx])
  aDizi.push("<a href='"+arrUrl[_idx].value+"'>"+_title+"</a>");
})
console.log(aDizi); // Ekranda görelimki listeyi kopyalayıp html dosyamıza yapıştırarak indireceğiz
jQuery candır. Onu sayfamıza bir ekleyelim.
<html>
<head>
    <script src=http://code.jquery.com/jquery-2.1.4.min.js></script>
Sayfamızda data-saveas propertysi olan a etiketlerinin üstünden geçerek href özelliklerindeki adresten akışı indireceğiz ve Blob'a yazarak tekrar a etiketine bağlayacağız.
    <script type=text/javascript>
        $(function() {
            // iterate over all the items that are marked as saveas
            $('a[data-saveas]').each(function() {
                var $this = $(this);

                // İndirmek istediğimiz adres ve diske hangi isimle kaydetmek istiyorsak, yeni dosya adı
                var target = $this.prop('href'),
                    saveas = $this.data('saveas');

                // kaynaktan dosyayı indirmek için ajax kullanacağız
                $.ajax({
                    url: target,
                    type: 'GET',
                    mimeType: 'text/plain; charset=x-user-defined', 
                    error: function(a, b, c, d) {
                        debugger;
                    }
                }).done(function(data, textStatus, jqXHR) {

                    // VERİYİ ÇEKTİK VE ŞİMDİ BLOB OLARAK SAKLAYACAĞIZ
                    var bufferBos = new Int8Array(new ArrayBuffer(data.length));
                    for (var i = 0; i < data.length; i++) {
                        var charCode = data.charCodeAt(i); // ascii
                        bufferBos[i] = charCode; // gelen her byte'ı 8 bitlik(octet) elemanlar olarak diziye yerleştirelim
                    }
                    // Blob oluşturmak yapıcı olarak veriyi ve verinin tipini vermemiz gerekiyor
                    // new Blob([bufferlanmış veri], { type: mimeString })
                    var mimeString = jqXHR.getResponseHeader('Content-Type');
                    var blob = new Blob([bufferBos], { type: mimeString });


                    // ŞİMDİ DEFAULT HREF BİLGİLERİNE GÖRE KAYDETMEMEK İÇİN DÜZENLEYELİM
                    // Blob içine kaydettiğimiz veriye erişebilmek için URL oluşturacağız.
                    var href = (window.webkitURL || window.URL).createObjectURL(blob);
                    $this.prop({
                        // Tıklandığında download propertysinden yer alan ad ile kaydedecek
                        'download': saveas,
                        'href': href,
                        'draggable': true
                    }).data({
                        // <a href="#" class="dnd" data-downloadurl="MIME_Type:File_Name:Blob_URL"></a>
                        // Örneğin:
                        // <a href="#" class="dnd" data-downloadurl="image/jpeg:Penguins.jpg:https://www.box.net/box_download_file?file_id=f66690"></a>
                        'downloadurl': [mimeString, saveas, href].join(':')
                    });
                });
            });
        });
    </script>
</head>
HTML dosyamıza bağlantılarımızı da ekleyerek tamamlayalım. Sayfa yüklendiğinde tüm a elemanlarının içinde dolaşarak ilgili dosyaları blob halinde browser'da tutacak ve tıkladığımızda belirttiğimiz dosya adıyla kaydetmiş olacağız.
<body>
    0: <a href='http://radio-download.dw.de/Events/podcasts/tur/3803_DKpodcast_dwn1_tur/DWN_Tuerkisch_Serie1_Lektion01-podcast-3803-293588.mp3' data-saveas='Ders 01 - Bu bir şarkı.mp3'>Ders 01 - Bu bir şarkı</a>
    <br />1: <a href='http://radio-download.dw.de/Events/podcasts/tur/3806_DKpodcast_dwn3_tur/00eb5664-podcast-3806-306737.mp3' data-saveas='Ders 26 - Yalnızca birlikte olmak istiyoruz.mp3'>Ders 26 - Yalnızca birlikte olmak istiyoruz</a>
    <br />2: <a href='http://radio-download.dw.de/Events/podcasts/tur/3806_DKpodcast_dwn3_tur/00eb5675-podcast-3806-306736.mp3' data-saveas='Ders 25 - Önce ufak siparişler gelmesini umuyorum.mp3'>Ders 25 - Önce ufak siparişler gelmesini umuyorum</a>
..
...
....

</body>
</html>
Haydi sonucuna bakalım. Önce dosyanın indiğini chrome network sekmesinden görelim:
Şimdide tıkladığımızda ne olduğuna:
Hepsi bu :)

5 Ekim 2015 Pazartesi

json-schema-defaults ile node.js üstünde .json uzantılı şemaları dinamik yüklemek

Tüm kodunu en aşağıya yapıştırdım ama ekelediğim yeri biraz anlatmış olayım:
var getRemoteRef = function (_uri, definitions) {
// loadschema ileride async olarak şema yüklemelerini sağlamak için kullanacağım için şimdiden hazır edeyim dedim.
    var loadSchema = function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    };

    // node uygulamasının hangi fiziksel klasörde olduğunu buluyorum
    var appRoot = require('app-root-path'),
        // dosya yolunun schema'lı halini oluşturuyorum
        indexOfSchema = _uri.indexOf('/schema/');

    // .json dosyasının tam yolunu bulduktan sonra 
    var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
    console.log("Path: " + filePath);

    // reuqire ile çekiyoruz
    var result = require(filePath);

    if (!isObject(result)) {
        return result;
    }
    return cloneJSON(result);
}
(function (root, factory) {

    'use strict';

    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
        // CommonJS
        module.exports = factory();
    } else if (typeof define === 'function' && define.amd) {
        // AMD
        define('json-schema-defaults', [], function () {
            return factory();
        });
    } else {
        // global with noConflict
        var jsonSchemaDefaults = root.jsonSchemaDefaults;
        root.jsonSchemaDefaults = factory();
        root.jsonSchemaDefaults.noConflict = function () {
            var defaults = root.jsonSchemaDefaults;
            root.jsonSchemaDefaults = jsonSchemaDefaults;
            return defaults;
        };
    }

}(this, function () {

    'use strict';

    var ajv = null;

    /**
     * check whether item is plain object
     * @param {*} item
     * @return {Boolean}
     */
    var isObject = function (item) {
        return typeof item === 'object' && item !== null && item.toString() === {}.toString();
    };

    /**
     * deep JSON object clone
     *
     * @param {Object} source
     * @return {Object}
     */
    var cloneJSON = function (source) {
        return JSON.parse(JSON.stringify(source));
    };

    /**
     * returns a result of deep merge of two objects
     *
     * @param {Object} target
     * @param {Object} source
     * @return {Object}
     */
    var merge = function (target, source) {
        target = cloneJSON(target);

        for (var key in source) {
            if (source.hasOwnProperty(key)) {
                if (isObject(target[key]) && isObject(source[key])) {
                    target[key] = merge(target[key], source[key]);
                } else {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };

    /**
     * merge list of objects from allOf properties
     * if some of objects contains $ref field extracts this reference and merge it
     *
     * @param {Array} allOfList
     * @param {Object} definitions
     * @return {Object}
     */
    var mergeAllOf = function (allOfList, definitions) {
        var length = allOfList.length,
            index = -1,
            result = {};

        while (++index < length) {
            var item = allOfList[index];

            item = (typeof item.$ref !== 'undefined') ? getLocalRef(item.$ref, definitions) : item;

            result = merge(result, item);
        }

        return result;
    };

    /**
     * get object by reference. works only with local references that points on
     * definitions object
     *
     * @param {String} path
     * @param {Object} definitions
     * @return {Object}
     */
    var getLocalRef = function (path, definitions) {
        path = path.replace(/^#\/definitions\//, '').split('/');

        var find = function (path, root) {
            var key = path.shift();
            if (!root[key]) {
                return {};
            } else if (!path.length) {
                return root[key];
            } else {
                return find(path, root[key]);
            }
        };

        var result = find(path, definitions);

        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    };


    var getRemoteRef = function (_uri, definitions) {
        var loadSchema = function (uri, callback) {
            var request = require('request');
            request(uri, function (err, res, body) {
                console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

                if (err || res.statusCode >= 400)
                    callback(err || new Error('Loading error: ' + res.statusCode));
                else {
                    callback(null, JSON.parse(body));
                }
            });
        };

        var Path = require('path'),
            appRoot = require('app-root-path'),
            indexOfSchema = _uri.indexOf('/schema/');

        var filePath = appRoot + "/node/" + _uri.substr(indexOfSchema);
        console.log("Path: " + filePath);
        var result = require(filePath);
        if (!isObject(result)) {
            return result;
        }
        return cloneJSON(result);
    }


    /**
     * returns a object that built with default values from json schema
     *
     * @param {Object} schema
     * @param {Object} definitions
     * @return {Object}
     */
    var defaults = function (schema, definitions) {
        console.log("schema: " + JSON.stringify(schema, null, ' '));
        console.log("definitions: " + JSON.stringify(definitions));
        if (typeof schema['default'] !== 'undefined') {

            return schema['default'];

        }
        else if (typeof schema.allOf !== 'undefined') {

            var mergedItem = mergeAllOf(schema.allOf, definitions);
            console.log("MergedItem: " + JSON.stringify(mergedItem));
            return defaults(mergedItem, definitions);

        }
        else if (typeof schema.$ref !== 'undefined') {
            console.log("Reference name: " + schema.$ref);
            var reference;
            if (schema.$ref.indexOf("http") == 0) {
                reference = getRemoteRef(schema.$ref, definitions);
                //reference= getRemoteRef("http://localhost:3000/schema/providers/login/test.json", definitions);
            } else {
                reference = getLocalRef(schema.$ref, definitions);
            }

            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

        }
        else if (schema.type === 'object') {

            if (!schema.properties) {
                return {};
            }

            for (var key in schema.properties) {
                if (schema.properties.hasOwnProperty(key)) {
                    schema.properties[key] = defaults(schema.properties[key], definitions);

                    if (typeof schema.properties[key] === 'undefined') {
                        delete schema.properties[key];
                    }
                }
            }

            return schema.properties;

        }
        else if (schema.type === 'array') {

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }
        else if (schema.type && typeof(schema.type) === 'object') {

            console.log("Reference name: " + schema.type.$ref);
            var reference = getLocalRef(schema.$ref, definitions);
            console.log("Refernce: " + JSON.stringify(reference));
            return defaults(reference, definitions);

            if (!schema.items) {
                return [];
            }
            return [defaults(schema.items, definitions)];

        }

    };

    /**
     * main function
     *
     * @param {Object} schema
     * @param {Object|undefined} definitions
     * @return {Object}
     */
    return function (schema, definitions, _ajv) {
        ajv = _ajv;

        if (definitions && Array.isArray(definitions)) {
            var defs = {};
            definitions.forEach(function (_definition) {
                defs = merge(_definition, schema.definitions);
            });
            definitions = defs;
        }

        if (typeof definitions === 'undefined') {
            definitions = schema.definitions || {};
        }
        else if (isObject(schema.definitions)) {
            definitions = merge(definitions, schema.definitions);
        }

        return defaults(cloneJSON(schema), definitions);
    };

}));

AJV'yi JSON doğrulamalarında kullanmak




Node.js üstünde AJV'de harici referansları olan ".json" uzantılı şemaların yüklenmesini birazcık anlatayım. Kodları test etmeden yazıyorum asıl olan temelde neyin döndüğüdür.

Ana şemamız index.json ve içinde harici referans olarak test.json'ı içersin (bkz. definitons -> "TW": {"$ref": "http://localhost:3000/schema/providers/login/test.json"}
{
  "id": "http://localhost:3000/schema/providers/login/index",
  "title": "Providers",
  "$schema": "http://json-schema.org/draft-04/schema#",
  "description": "Kullanıcı Giriş Sağlayıcıları",
  "type": "object",
  "definitions": {
    "TW": {"$ref": "http://localhost:3000/schema/providers/login/test.json"}
  },
  "additionalProperties": false,
  "properties": {
    "TW": {"$ref": "#/definitions/TW"}
  }
}
test.json
{
  "id": "http://localhost:3000/schema/providers/login/test.json",
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer",
      "default": 0
    },
    "id_str": {"type": "string"},
    "name": {
      "type": "string",
      "default": ""
    }
  },
  "required": [
    "id",
    "name"
  ]
}
Her iki şemanın ID'sinin, URL adresleri olduğuna dikkat! Çünkü bu sayede hem eşsizliği sağlamış olursunuz hem de bağlantılarını kopartmamış olursunuz. Ayrıca $ref kısmını definitions içinde veriyor ve properties içindeki özelliklere buradan verdiğimiz için aynı tipi başka bir yerde kullansakta bir kez http talebi yapmış olacağız (Örn. properties:{ ev_adresi:{$ref:'http:/..../adres.json'}, is_adresi:{$ref:'http:/..../adres.json'}, ..} olsaydı aynı json 2 kez çağrılmış olacaktı).

addSchema metodu

2 Parametre alıyor; ilki şemanın kendisi(json nesnesi olacak), ikincisi ise eğer şemanın içinde "id" tanımlanmamışsa kullanılması için sizin belirteceğiniz "id" değeri(string olacak).
var Ajv = require('ajv'),
    ajv = Ajv({removeAdditional:true});

function addSchema() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    ajv.addSchema(schIndex);
    var bValid = ajv.validate(schIndex.id, {TW: {id: 2, a: 1, name: "cem"}});
    if (!bValid) {
        console.log("Hatalıysam ara: ");
        console.log(ajv.errors);
    }else{
        console.log("Herkül müsün kardeşim:");
        var sch2 = ajv.getSchema("http://localhost:3000/schema/providers/login/index");
        console.log(sch2.schema);
    }
}
addSchema();

compile metodu

var Ajv = require('ajv'),
    ajv = Ajv({removeAdditional:true});

function compile() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);  // önce test şemasını ekleyelimki index.json içinde kullanılmadan önce hazır olsun
    var validate = ajv.compile(schIndex); // index.json'ı derleyerek doğrulayacak fonksiyonumuza ulaşalım.
    console.log(validate.schema) // şemamızın içinde test.json'ı referans olarak görürüz ama doğrulama sırasında bu referanslara bakarak veri nesnesini doğrulayacaktır
    var a = validate({TW: {id: 2, name: "cem"}})  // hata vermez ve başarıyla doğrulanmış olur

    if(validate.errors){
      console.log(validate.errors)
    }else{
      console.log(a);
    }
}
compile();

compileAsync metodu

Bu fonksiyonu kullanmadan önce asenkron olarak yükleme işini yapacak fonksiyonu tanımlamalısınız ve yükleme tamamlandıktan sonra doğrulama yapacak callback fonksiyonunu girmelisiniz. Bunun için AJV'nin options larından loadSchema'yı kullanacağız.

ajv = Ajv({
    loadSchema: function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log(body); // Bu gelen şemayı doğrulamaya göndermeden önce JSON'a çevirmelisiniz.

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    }
});

function compileAsync() {
    var sch = require('./providers/login/index.json');
    console.log("sch--------------");
    console.log(JSON.stringify(sch));

    ajv.compileAsync(sch, function (err, validate) {
        console.log(validate); // görelim ne var elimizde

        if (err) return; // hata varsa dön bebeğim

        var a = validate({TW:{id: 2, name: "cem"}});
        console.log(validate.errors); // null döner
        console.log(a);  // true döner(hatasız);
    });
}
compileAsync();
Tüm kod:
var Ajv = require('ajv'),
//sch = require('./index'),
    ajv = Ajv({removeAdditional: true}); // options can be passed
ajv = Ajv({
    loadSchema: function (uri, callback) {
        var request = require('request');
        request(uri, function (err, res, body) {
            console.log("request ended");
            console.log(body);

            if (err || res.statusCode >= 400)
                callback(err || new Error('Loading error: ' + res.statusCode));
            else {
                callback(null, JSON.parse(body));
            }
        });
    }
});


function compile() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    var validate = ajv.compile(schIndex);
    console.log(validate.schema);
    var a = validate({TW: {id: 2, name: "cem"}});
    console.log(validate.errors);
    console.log(a);
}
//compile();

function compileAsync() {
    var sch = require('./providers/login/index.json');
    console.log("sch--------------");
    console.log(JSON.stringify(sch));

    ajv.compileAsync(sch, function (err, validate) {
        console.log(validate);
        console.log("neredeyim")
        console.log("err: " + err);
        if (err) return;

        var a = validate({id: 2, name: "cem"})
        console.log(validate.errors)
        console.log(a);

        console.log("buradayım");
    });
}
//compileAsync();

function addSchema() {

    var schTest = require('./providers/login/test.json');
    var schIndex = require('./providers/login/index.json');
    ajv.addSchema(schTest);
    ajv.addSchema(schIndex);
    var bValid = ajv.validate(schIndex.id, {a: 1,TW: {id: 2, name: "cem"}});
    if (!bValid) {
        console.log("Hatalıysam ara: ");
        console.log(ajv.errors);
    }else{
        console.log("Herkül müsün kardeşim:");
        var sch2 = ajv.getSchema("http://localhost:3000/schema/providers/login/index");
        console.log(sch2.schema);
    }
}
//addSchema();

6 Mayıs 2015 Çarşamba

JSON Schema ile nesnelerinizi doğrulama ya da şemaya uygun başlangıç nesneleri tanımlama

Şimdilik zaman azlığı çektiğimden anahtar kelimeler ve biraz kod parçası atacağım.
NPM Kütüphaneleri:
  1. json-schema-defaults
  2. is-my-json-valid

Şablon olması için kullanabilirsiniz Webstorm içinde:
module.exports = {
    "$schema": "http://json-schema.org/draft-04/schema#",
    name: "BenimSchemaM",
    description:"Örnek şema olsun diye az açıklamalı olarak yazabildim.Daha ilişki yönetimleri vardı :(",
    definitions: {},
    type: "object",     // şemanın doğrulayacağı ya da şemadan oluşturulacak nesnenin tipi. string, object, array...
    required: [],       // string dizisi. Olması mecburi property isimlerini içerir

    additionalProperties: false,    // Şemada tanımlı olmayan ama şemaya uygun olduğunu iddia eden nesnenin fazladan propertysine müsade et/me

    properties: {
        Id: {type: "number", default: 0},
        WebAdresi: {type: "string", format: "url"},
        dizi: {
            type: "array",              // dizi property sinin tipi ARRAY olacak ve
            items: {type: "string"}     // içindeki her eleman string tipinde olacak
        }
    }
};

Miras Alma(Inheritance) ya da Genişletme(Extend)

Bir esas bir de onu miras alacak şemamız olsun.
module.exports = {
    name: "Kullanıcı",
    description: "Session içinde kullanılacak kullanıcı",
    type: "object",
    definitions: {
        Providers: require('../providers/login')
    },
    required: ["Id", "Providers"],
    properties: {
        Id: {type: "integer", default: 0},
        AdiSoyadi: {type: "string"},
        EPosta: {type: "string", format: "email"},
        Sifre: {type: "string"},
        Providers: {$ref: "#/definitions/Providers", default: {}}
    },
    additionalProperties: true
};

Miras alarak yeni bir şema oluşturalım:
var tahtaRolu = {

    $schema: "http://json-schema.org/draft-04/schema#",
    description: "Tahtanın rollerini içerir >  HS > tahta:401:rol : Tahtanın rolleri > 1 | {adi:'Sahip', Yetkileri:['Ihale Girişi','Ihaleye Katılım', 'Teklif Girişi'] }",
    type: "object",
    required: ["Id", "Adi", "Yetki"],
    definitions: {
        Kullanici: require('../ortak/kullanici'),
        Rol: require('./tahtaRolu')
    },
    allOf: [
        {$ref: "#/definitions/Kullanici"},
        {
            properties: {
                Rol: {$ref: "#/definitions/Rol"}
            }
        }
    ],
    additionalProperties: false
};

module.exports = tahtaRolu;
Sonuç:

5 Mayıs 2015 Salı

JSDoc ile javascript kodlarınızın belgelendirilmesi

/**
* My js app
* @module app
*/

/** 
* Namespace for MYAPP classes and functions.
* @namespace MYAPP
*/
var MYAPP = MYAPP || {};

/**
* A maths utility
* @class
*/
MYAPP.math_stuff = {

    /**
    * Sums 2 numbers
    *
    * @property sum
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} Sum of the inputs
    */
    sum: function (a, b) {
        return a + b;
    },

 /**
 * Yaş bilgisini tutar
 * @property yas
 */
 yas : 12,
    /**
    * Multiplies 2 numbers
    *
    * @property multi
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} The inputs multiplied
    */
    multi: function (a, b) {
        return a * b;
    }
};

/**
* My js app
* @module app
*/
/** 
* Namespace for MYAPP classes and functions.
* @namespace HUMAN_RESOURCE
*/
var HUMAN_RESOURCE = HUMAN_RESOURCE || {};

/**
* @class JustClass
* @constructor
*/
HUMAN_RESOURCE.JustClass = function(){ }

/**
* Constructs Person objects
* @class Person
* @constructor
* @param {String} First name
* @param {String} Last name
*/
HUMAN_RESOURCE.Person = function (first, last) { 
    /**
    * @property f_createPerson
 * @param {Person} [_person] açıklama
    * @return {Person} Person type object
    */
 this.f_createPerson = function(_person, _person2){ return new Person() }
};

/**
* Return Person's full name
* @alias getName
* @memberof! HUMAN_RESOURCE.Person#
* @return {String} First name + last name
*/
HUMAN_RESOURCE.Person.prototype.getName = function () {
    return this.first_name + ' ' + this.last_name;
};


21 Nisan 2015 Salı

Javascript Singleton Pattern


function Single(){
  if(Single.caller !== Single.getInstance){
     throw new Error("new ile çalıştırılamaz");
  }

  this.dt = new Date();
}

Single.getInstance = function() {
  // Single sınıfına ait instance static özelliği yaratılmadan önce
  console.dir(this);
debugger;
  if(this.instance === undefined){
    // this tanımı doğrudan sınıfı yani Single fonksiyonunu işaret edecektir
    this.instance = new Single();
  
    // Single sınıfının instance static özelliği yaratıldı
    // Ve bundan sonra bir daha yaratılmayıp sınıfa bağlı instance nesnesi gönderilecek
    console.dir(this);
  }
  return this.instance
}

// Single sınıfının static fonksiyonu olan getInstance üstünden tekil nesne çağırılır
a = Single.getInstance();

// new Anahtarıyla Single sınıfından bir nesne tanımlanamaz
a = new Single();

Peki node.js içinde nasıl olurdu? Unutmamalı ki require ile çağırdığımız tüm js dosyaları memorye bir kez yüklenir ve her require ile çağrıldığında artık file i/o yapmak yerine bellekten getirilir. Ve biz objemizi bir kez module.exports içine koydukmu bir daha yaratmak durumunda olmayız. Yukarıdaki kodu single.js olarak sakladığımızı düşünelim.
single.js
module.exports = Single.getInstance()
çağırdığımız dosya.js olsun:
module.exports = require('./single.js')

7 Nisan 2015 Salı

Javascript Patterns

Javascript Pattern'ler:

Module, Revealing Module ve Prototype Pattern'in

Constructor Pattern:

Factory Pattern:

9 Mart 2015 Pazartesi

JSON validator

Çok başarılı bir doğrulayıcı. Örneğim olsun deyyu ekliyorum:

https://github.com/mafintosh/is-my-json-valid
var trueString = {
    required: true,
    type: 'string'
},
falseString = {
    required: false,
    type: 'string'
},
trueBoolean = {
    "type": "boolean",
    required: true
},
falseBoolean = {
    type: 'boolean',
    required: true
},
trueNumber = {
    type: 'number',
    required: true
},
trueInteger = {
    type: 'integer',
    required: true
};

var boardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: trueString,
        id: {
          type: 'integer',
          format: 'sadeceSifir'
      }
    }
},
 digerBoardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: trueString,
        id: {
          type: 'integer',
          format: 'sadeceSifir'
      }
    }
}

var validate = validator(
                         { $ref: '#digeri' }, 
                         { 
                           schemas: { board: boardSchema, digeri: digerBoardSchema  }, 
                           formats: { sadeceSifir:/^0$/, sadece1:/^1$/ }
                         }
                        )


console.log(validate({ name: 'New board', id: 0 }));

Diğer örnek:
var validator = isMyJsonValid


var boardSchema = {
    required: true,
    type: 'object',
    properties: {
        name: {
            required: true,
            type: 'string'
        },
        id: {
            type: 'integer',
            format: 'sadece1'
        },
        columns: {
            type: 'array'
        },
        roles: {
            type: 'array'
        },
        users: {
            type: 'object',
            required: true,
            properties: {
                invitees: {
                    type: 'array'
                },
                members: {
                    type: 'array'
                }
            }
        },

    }
};

var schemaFormats = {
    schemas: {
        board: boardSchema
    },
    formats: {
        sadeceSifir: /^0$/,
        sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
        date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
    }
}

var validate = validator({
    $ref: '#board'
}, schemaFormats)


console.log(validate({
    name: 'New board',
    id: 1,
    users:{invitees1:[], members:[]}
}));


Node.js içinde kullanmak için yazdım
var validator = require('is-my-json-valid');


function f_validate(_obj, _schemaName) {
    var schema_member = {

        },
        schema_users = {
            type: 'object',
            required: true,
            properties: {
                invitees: {
                    type: 'array'
                },
                members: {
                    type: 'array'
                }
            }
        },
        schema_board = {
            required: true,
            type: 'object',
            properties: {
                name: {
                    required: true,
                    type: 'string'
                },
                id: {
                    type: 'integer',
                    format: 'sadece1'
                },
                columns: {
                    type: 'array'
                },
                roles: {
                    type: 'array'
                },
                users: schema_users
            }
        };

    var schemaFormats = {
        schemas: {
            board: schema_board,
            users: schema_users,
            member: schema_member
        },
        formats: {
            sadeceSifir: /^0$/,
            sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
            date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
        }
    }

    var validate = validator({$ref: '#' + _schemaName}, schemaFormats);

    var result = validate(_obj);
    console.log(validate.errors);

    return result;
}


module.exports = f_validate;

Bu daha iyisi:
var validator = require('is-my-json-valid');
var schema_member = {

    },
    schema_users = {
        type: 'object',
        required: true,
        properties: {
            invitees: {
                type: 'array'
            },
            members: {
                type: 'array'
            }
        }
    },
    schema_board = {
        required: true,
        type: 'object',
        properties: {
            name: {
                required: true,
                type: 'string'
            },
            id: {
                type: 'integer',
                format: 'sadece1'
            },
            columns: {
                type: 'array'
            },
            roles: {
                type: 'array'
            },
            users: schema_users
        }
    },
    schemaFormats = {
        schemas: {
            board: schema_board,
            users: schema_users,
            member: schema_member
        },
        formats: {
            sadeceSifir: /^0$/,
            sadece1: /^1$/,
            'date-time': /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}[tT ]\d{2}:\d{2}:\d{2}(\.\d+)?([zZ]|[+-]\d{2}:\d{2})$/,
            date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-[0-9]{2}$/
        }
    }


function f_filterAndValidate(_obj, _schemaName) {
    this.schemaName = _schemaName;
    this.obj = _obj;

    this.f_filter = function () {
        var filter = validator.filter({$ref: '#' + this.schemaName}, schemaFormats)
        return filter(this.obj);

    };

    this.f_validate = function (_filtered_object) {

        var validate = validator({$ref: '#' + this.schemaName}, schemaFormats);

        var result = validate(_filtered_object);
        console.log(validate.errors);

        return result;
    };

    return this.f_validate(this.f_filter())
}


module.exports = {
    schemas_board: 'board',
    schemas_users: 'users',
    'f_filterAndValidate': f_filterAndValidate
};

24 Mayıs 2013 Cuma

Mustache Template Örneği

Ref: NetTuts - Youtube

// Değişkenleri en üstte tanımlamak iyi, window içinde tanımlamak kötüdür !
var data, template, html;

data = {
  name : "Site adı",
  sites: ["Nettuts+", "Psdtuts+","Mobiletuts+"],
  url: function(){
    return function(text,render){
       text = render(text);
       var url = text.trim().toLowerCase().split('tuts+')[0] + '.tutsplus.com';
       return ''+text+'';
    }
  }

  tempalte = "

{{name}}

    {{#sites}}
  • {{#url}} {{.}} {{/url}}
  • {{/sites}}
"; html = Mustache.to_html(template, data); document.write(html);
data nesnesinin url özelliğini anlamak için:
http://stackoverflow.com/a/6849232/104085
http://mustache.github.io/mustache.5.html

11 Mayıs 2013 Cumartesi

Neden this veya prototype kullanırız?

PERFORMANS

Eğer bir A fonksyionundan new ile birçok nesne tanımlayacaksak, A fonksiyonunda this.xxx ile tanımlı her fonksiyon tüm nesneler için tek tek oluşturulur.
var A = function () {
    this.x = function () {
        //do something
    };
};

// Aşağıdaki tanımlamada tek bir fonksiyon tüm örnekler için kullanılır
// ve bu şekilde memory daha az kullanılır.
var A = function () { };
A.prototype.x = function () {
    //do something
};
Ref: http://jsperf.com/prototype-vs-this

GİZLEMEK

Fonksiyon içindeki private değişkenleri, public fonksiyonlardan gizlemek istersek, prototype içinde public fonksiyonlarını tanımlarız. Böylece A fonksyonu içindeki private_var erişilmez olur. Sadece A içinde this ile tanımlı kaynaklara prototype içinde tanımlı fonksiyonlar erişir.

__proto__ ne işe yarar

Bir fonksiyonun prototype özelliği otomatik olarak tanımlanır ve içindeki bilgiler o fonksiyondan üretilen nesnelere geçer. Üretilen her nesne __proto__ bilgisi içinde fonksyionun prototype özelliğindeki nesneyi saklar ve aranan her property eğer birinci seviyede nesnede yoksa __proto__ içinde aranır. Bulunamazsa __proto__.__proto__ içinde ve en son __proto__ ya kadar aranır.

prototype.constructor ne işe yarar

Fonksiyonun varsayılan özelliği prototype idi ve constructor ile __proto__ dan oluşuyordu.
Fonksiyonun atasını prototype içinden öğreniyoruz.
Function dan miras alınanlar:
Eğer prototype özelliğini başka bir fonksiyondan olma nesne ile ezersek:
Eğer daha A fonksiyonunun prototype'ını B fonksiyonuyla ezip,
A fonksiyonundan olma bir a nesnesinin constructor fonksiyonundan c nesnesi yaratmak istersek,
elbetteki B fonksiyonundan üretilmiş olacak çünkü A'nın prototype özelliğini B yapmıştık.

Kısaca constructor ile objenin atasına ait fonksiyona bağ kurmuş oluyoruz. Eğer nesnenin üstünden new ile bir başka nesne yaratmak istersek constructor fonksiyonu işimize yarayacaktır.



Javascript Sınıflarında prototype atanması

1)

2)


Sınıfların durumunu daha derin incelersek:

Herhangi bir inheritance(miras, kalıtım) uygulanmadığı için B sınıfı varsayılan olarak Object sınıfından miras alır. Bu durumda B'den yaratılacak nesneler için ilk aranacak metotlar B sınıfının içindekiler sonra B'nin miras aldığı Object sınıfı içindekiler olacak.
Nesnenin daima __proto__ su vardır ve inherit ettiği sınıfların bilgilerini barındırır.
Bir nesne içinde property araması yapıldığında önce kendi içinde (hasOwnProperty) sonra inherit ettiği sınıfların içinde propertylerde arama yapar.
var b = new B();
b.__proto__ 
B {}
b.__proto__.__proto__
Object {}
b.__proto__.__proto__.__proto__
null

Object.create ile inheritance:


new Operatörüyle inheritance:


B nin prototype'ı için Object.create ile A yı B sınıfının atası olarak tayin ettiğimizde, A dan bir nesne yaratılmaz ve tüm property leri B sınıfından yaratılan nesnelere geçirilmez.

Miras alan sınıfa, sanki atadan geliyormuş gibi yeni fonksiyon ve özellikler eklemek


Object.create(param1,param2)
param1: Miras alınan sınıf
param2: Sanki miras alınan sınıftan geliyormuş gibi eklenen fonksiyon ve özellikler. Dikkat edilecek nokta: Miras alınan sınıfa yeni eklenen fonksiyon ve özellikler geçmez!

KALITIMI YOK ETMEK



null veya Object.create(null) ile sınıfın, ata sınıfla ilişiği kesildiği anda, prototype'ı null yapılan sınıflardan türetilen nesnelerin __proto__ özelliği Object ile yer değişir.

Güzel Kaynaklar:
http://javascriptweblog.wordpress.com/2010/06/07/understanding-javascript-prototypes/
http://dailyjs.com/2012/06/04/js101-object-create/
http://www.javascripture.com/

25 Nisan 2013 Perşembe

jQuery üzerinden observer pattern oluşturulması

$ içinde tanımlı olan ve jQuery nesnelerine sarılan on, off, trigger metotları vardır. trigger Metodu bir tetikleyicidir ve hangi olayın tetiklenmesini istiyorsak, ilgili değişkenleri ikinci parametrede vererek çalıştırırız.


on Metodu bir olayın tetiklenmesi halinde çalışır. Birinci parametre hangi event durumunda çalışacağını, ikinci parametre ise hangi fonksiyonun çalışacağını gösterir.


off Metodu ise daha önce bir olaya eklenmiş bir metodun kaldırılması esasına dayanır.


Yukarıdaki bu metotların çalışabilmesi için önce hangi nesneye kilitlediğinizi seçmelisiniz ve bu nesne tabii ki jQuery örneği olmalı. Mesela her div'e tıklandığında zapa zupa olsun: $('div').on('click',zapaZupaFonksiyonunuCagir());
Eğer bir tıklama olmadan programatik olarak çağırmak isterseniz $('div').trigger('click',['extra parametreler']); ile çağırabilirsiniz olayları.

Şimdi biliyoruzki jQuery nesneleri on,off,trigger metotlarına sahiplerken $ buna sahip değil. Bunu sağlamak için bir jQuery nesnesi yaratalım:
var o = $({});
Bu nesneden o.trigger() diyerek metot çağırmakla o['trigger']() diyerek metot çağırmak arasında bir fark yoktur. Neticede javascript nesnesinin bir özelliğini çağırıyoruz ve fonksiyonlarda bu nesnelerin bir propertysi gibidirler.


Peki 'on' metodunun içeriği zaten jQuery içinde tanımlanmış ve sadece nesnelere bağlanabiliyorsa biz jQuery örneğimiz için on fonksiyonunun adını değiştirebilir miyiz?
o['hebeleOlsun'] = function(){ o.on.apply(o, arguments); }; burası azıcık karışık gelebilir. Baş taraf çok basit. hebeleOlsun diye bir özellik ekliyoruz "o" nesnemize. Bu nesneye anonymous bir function atıyoruz. Bu durumda o['hebeleOlsun']() ya da o.hebeleOlsun() çağrıları bu anonymous fonksiyona çağrı yapacak ve tüm parametrelerde bu metot içinde arguments dendiğinde elde edilebilecek. Şimdi sırada apply var. apply da bir metot çağrısı ama kime yapılıyor? Bir başka metotan yapılabiliyor ki burada bizim "on" metodumuzun üstünden yapıldığını farketmişsinizdir. Peki parametrelerin anlamı ne? Birinci parametre bu fonksiyon içinde this diyerek elde edebileceğimiz değişken olacak. Ki; biz burada o nesnesini gönderdik. Böylece apply ile çağırdığımız on fonksiyonu içinde artık this = o olmuştur. ON fonksiyonunun içine diğer diğer parametreleride arguments ile gönderiyoruz.

Peki biz jQuery içinden özelleştirilmiş bir olay oluşturma, bu olaya abone olma ve aboneliği silmek konusununu nasıl yazabiliriz:
<script>
        var o = $({});

        jQuery['yayinYap'] = function () {
            o.trigger.apply(o, arguments);
        };

        jQuery['uyeOl'] = function () {
            o['on'].apply(o, arguments);
        };

        jQuery['uyeOlma'] = function () {
            o['off'].apply(o, arguments);
        };

        $.yayinYap('onBasimKasindi',['bu bir event parametresi','bu da digeri',2,3,{oz:'el',li:'ck'}]);

        $.uyeOl('onBasimKasindi',function(e){ console.log('Başı kaşınan birisi var'); console.log(e); $.uyeOlma('onBasimKasindi','**'); });

Bunun pratik halleride var ama bu şeklini anladığınızda diğerleri daha anlamlı gelecektir.

Geç oldu, ben gider...

29 Mayıs 2011 Pazar

Javascript ile yeni şifre belirleme ve doğrulama


function Validatetextarea(field) {
var valid = "ABCDEFGHIJKLMNOPRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.";
var temp;

for (var i=0; i<field.length; i++) {
temp = "" + field.substring(i, i+1);
if (valid.indexOf(temp) == "-1") {
return false;
}
}
return true;
}

function checkForm(fp){
if (fp.www.value != "") {
if (Validatetextarea(fp.www.value)==false){
alert("Lütfen Türkçe karakter kullanmayınız.");
fp.www.focus();
fp.www.select();
return false;
}
}

if (fp.password.value == "") {
alert("Lütfen şifrenizi yazınız.");
fp.password.focus();
return false;
}

if (fp.password.value != fp.Repassword.value) {
alert("Girdiğiniz iki şifre bir birinden farklı");
fp.Repassword.focus();
return false;
}


fp.ok.disabled=true;
fp.ok.value='İşlem Yapılıyor...'
}

Javascript ile şifre üretme


function GeneratePassword() {

var length=6;
var sPassword = "";

var noPunction = 1;
var randomLength = 2;

if (randomLength) {
length = Math.random();

length = parseInt(length * 100);
length = (length % 7) + 6
}

for (i=0; i < length; i++) {
numI = getRandomNum();
if (noPunction) { while (checkPunc(numI)) { numI = getRandomNum(); } }
sPassword = sPassword + String.fromCharCode(numI);
}

document.WebSiteAdd.password.value = sPassword;
}

function getRandomNum() {
var rndNum = Math.random()
rndNum = parseInt(rndNum * 1000);
rndNum = (rndNum % 94) + 33;
return rndNum;
}

function checkPunc(num) {
if ((num >=33) && (num <=47)) { return true; }
if ((num >=58) && (num <=64)) { return true; }
if ((num >=91) && (num <=96)) { return true; }
if ((num >=123) && (num <=126)) { return true; }

return false;
}

30 Ocak 2011 Pazar

MasterPage içinde javascriptleri sayfaya eklemek


protected void Page_Load(object sender, EventArgs e)
{
f_ScriptLinkEkle();
}

/// <summary>
/// Bu metod ile script ve link etiketleri sayfanın en üstüne bir kere eklenir.
/// Böylece hangi klasördeki sayfa çağırılırsa çağırılsın tekrar js ve css leri eklemek gerekmez.
/// </summary>
void f_ScriptLinkEkle()
{
List lstScripts = new List();
lstScripts.AddRange(
new[]
{
"Scripts/jquery-1.3.2.js",
"Scripts/jquery-1.3.2-vsdoc.js",
"Scripts/jquery.blockUI.1.33.js",
"Scripts/jquery.blockUI.js",
"Scripts/jquery.fancybox/jquery.easing.1.3.js",
"Scripts/jquery.fancybox/jquery.fancybox-1.2.1.js",
"Scripts/jquery.fancybox/jquery.fancybox.css"
}
);

List lstLinks = new List();
lstLinks.AddRange(new[]
{
"App_Themes/OrderDefault/styles.css",
"Scripts/jquery.fancybox/jquery.fancybox.css"
});


string[] sarrSegments = Request.AppRelativeCurrentExecutionFilePath.Split(new[] { '/' });
string sUstDizin = "";
for (int j = 1; j < sarrSegments.Length - 1; j++)
{
sUstDizin += "../";
}

foreach (string script in lstScripts)
{
cpScripts.Controls.Add(new LiteralControl(""));
}

foreach (string link in lstLinks)
{
cpScripts.Controls.Add(new LiteralControl("<link href=\"" + sUstDizin + link + "\" type=\"text/css\" rel=\"stylesheet\"/>"));
}
}

21 Kasım 2010 Pazar

Javascript Trim


<html>
<body>
<textarea id="txt" rows="10" cols="40"></textarea>
<script type="text/javascript">

String.prototype.TrimLeft = function (chars) {
//debugger;
var re = chars ? new RegExp("^[" + chars + "]+/", "g")
: new RegExp(/^\s+/);
return this.replace(re, "");
}
String.prototype.TrimRight = function (chars) {
var re = chars ? new RegExp("[" + chars + "]+$/", "g")
: new RegExp(/\s+$/);
return this.replace(re, "");
}
String.prototype.Trim = function (chars) {
return this.TrimLeft(chars).TrimRight(chars);
}

var d = " ,asda,asdasd,asdasdads,asdasd, ";
var ta = document.getElementById("txt");
var sonuc = d.Trim().Trim(',');
ta.value = sonuc;
</script>
</body>
</html>

Denemesi:
http://jsfiddle.net/jsfiddleCem/hWPSB/

Güzel RegExp örnekleri:
http://gabrieljones.com/working-with-regular-expressions-in-javascript/

15 Kasım 2010 Pazartesi

Javascript ile window.open ve window.moveTo için 2 küçük fonksiyon


// Enum değerleri taşıyacak nesne
var Enum = new Object();

// Enum.KarakterBoyutu : Pencerenin body nesnesinin karakter büyüklüğünü değiştirmek için kullanacağım Enum.
Enum.KarakterBoyutu = { KUCUK: 10, ORTA: 12, BUYUK: 14 };

// Enum.EkranYeri : Pencerenin ekranın neresinde olacağını belirttiğim Enum
Enum.EkranYeri = { "SOL_UST": 1, "SOL_ORTA": 2, "SOL_ALT": 3, "ORTA_UST": 4, "ORTA_ORTA": 5, "ORTA_ALT": 6, "SAG_UST": 7, "SAG_ORTA": 8, "SAG_ALT": 9 };

// Enum.PencereAcOzellikleri : Yeni açılacak pencerenin varsayılan özelliklerini içeren Enum.
Enum.PencereAcOzellikleri = { width: 400, height: 100, top: 0, left: 0, toolbar: 0, menubar: 0, scrollbars: 0, resizable: 0, location: 0, directories: 0, status: 1 };

/* Basitçe Enum değerlerini değiştirmenin yolu
* Enum.PencereAcOzellikleri['width'] = 66;
* Enum.PencereAcOzellikleri.width = 55;
*/

//(
function f_YeniPencereOzellikleri(_width, _height, _top, _left, _toolbar, _menubar, _scrollbars, _resizable, _location, _directories, _status) {
Enum.PencereAcOzellikleri.width = _width;
Enum.PencereAcOzellikleri.height = _height;
Enum.PencereAcOzellikleri.top = _top;
Enum.PencereAcOzellikleri.left = _left;
Enum.PencereAcOzellikleri.toolbar = _toolbar;
Enum.PencereAcOzellikleri.menubar = _menubar;
Enum.PencereAcOzellikleri.scrollbars = _scrollbars;
Enum.PencereAcOzellikleri.resizable = _resizable;
Enum.PencereAcOzellikleri.location = _location;
Enum.PencereAcOzellikleri.location = _location;
Enum.PencereAcOzellikleri.directories = _directories;
Enum.PencereAcOzellikleri.status = _status;
return Enum.PencereAcOzellikleri;
}
//)

//(
function f_PencereAc(_sUrl, _sWindowName, _enumPencereOzellikleri, _enumEkranYeri) {
_enumPencereOzellikleri = _enumPencereOzellikleri
? _enumPencereOzellikleri
: Enum.PencereAcOzellikleri;

var sOzellikler = "";
for (var ozellik in _enumPencereOzellikleri) {
sOzellikler += ozellik + "=" + _enumPencereOzellikleri[ozellik]+",";
}

// Pencere nesnesinde açılmış pencerenin adını ve referansını taşıyoruz.
var Pencere = {};
Pencere.Adi = _sWindowName ? _sWindowName : 'pencere_' + Math.random(1000);
Pencere.PencereOzellikleri = _enumPencereOzellikleri;
Pencere.Window = window.open(_sUrl, Pencere.Adi, sOzellikler);

if (_enumEkranYeri) {
f_PencereyiTasi(_enumEkranYeri, Pencere);
}
}

function f_PencereyiTasi(_enumEkranYeri, _pencere) {
// Nokta ile pencerenin taşınacağı nihai nokta tutuluyor.
var Nokta = { Top: 0, Left: 0 };
// Ekranın ve pencerenin width ve height bilgilerini hesaplamak için tutalım.
var ekranW = screen.width;
var ekranH = screen.height;

var pencereW = _pencere.PencereOzellikleri.width;
var pencereH = _pencere.PencereOzellikleri.height;

switch (_enumEkranYeri) {
case Enum.EkranYeri.SOL_ALT:
Nokta.Left = 0;
Nokta.Top = ekranH - pencereH;
break;
case Enum.EkranYeri.SOL_ORTA:
Nokta.Left = 0;
Nokta.Top = (ekranH - pencereH) / 2;
break;
case Enum.EkranYeri.SOL_UST:
Nokta.Left = 0;
Nokta.Top = 0;
break;
case Enum.EkranYeri.ORTA_ALT:
Nokta.Left = (ekranW - pencereW) / 2;
Nokta.Top = ekranH - pencereH;
break;
case Enum.EkranYeri.ORTA_ORTA:
Nokta.Left = (ekranW - pencereW) / 2;
Nokta.Top = (ekranH - pencereH) / 2;
break;
case Enum.EkranYeri.ORTA_UST:
Nokta.Left = (ekranW - pencereW) / 2;
Nokta.Top = 0;
break;
case Enum.EkranYeri.SAG_ALT:
Nokta.Left = ekranW - pencereW;
Nokta.Top = ekranH - pencereH;
break;
case Enum.EkranYeri.SAG_ORTA:
Nokta.Left = ekranW - pencereW;
Nokta.Top = (ekranH - pencereH) / 2;
break;
case Enum.EkranYeri.SAG_ALT:
Nokta.Left = ekranW - pencereW;
Nokta.Top = ekranH - pencereH;
break;
}
_pencere.Window.moveTo(Nokta.Left, Nokta.Top);
}
//)

/*
Örnek Kullanımı:
<a href="#" onclick="f_PencereAc('resimYukleme.aspx?tur=URUNLER&id=<%=Request["id"] %>', 'UrunResmiYukle', f_YeniPencereOzellikleri(550,150),Enum.EkranYeri.ORTA_ORTA);">Resim Eklemek için Tıklayınız </a>
*/

2 Kasım 2010 Salı

Javascript ile metin içinde url bağlantısını A etiketi ile sarmak


<script type="text/javascript">
var metin = "blah http://www.yahoo.com ile Yahoo adresine http://google.com ile Google a bağlanabilirsiniz.";
var sonuc = metin.replace(/http:\/\/([a-z0-9.-]+)/g, '$1');
alert(sonuc);
document.write(sonuc);
</script>

1 Kasım 2010 Pazartesi

Javascript ile Regular Expression

http://www.javascriptkit.com/jsref/regexp.shtml





var kaynak = "Bir rakamdan sonra 1 yazi aranacak.";

var filitre = /(\d+) yazi/;
var sonuc = kaynak .match( filitre );

console.debug(sonuc) ;


// ------ YA DA ----------------


var regEx = RegExp(/(\d+) yazi/);
var digerSonuc = regEx.exec(kaynak);

console.debug( digerSonuc );




http://stackoverflow.com/questions/369147/javascript-regex-to-extract-anchor-text-and-url-from-anchor-tags
var matches =[];

input_content.replace(/[^<]*(<a href="([^"]+)">([^<]+)<\/a>)/g, function(){

    matches.push(Array.prototype.slice.call(arguments, 1, 4))
});


This assumes that your anchors will always be in the form <a href="...">...</a> i.e. it won't work if there are any other attributes (for example, target). The regular expression can be improved to accommodate this.



To break down the regular expression:



/ -> start regular expression
[^<]* -> skip all characters until the first <

( -> start capturing first token
<a href=" -> capture first bit of anchor
( -> start capturing second token
[^"]+ -> capture all characters until a "
) -> end capturing second token
"> -> capture more of the anchor
( -> start capturing third token
[^<]+ -> capture all characters until a <

) -> end capturing third token
<\/a> -> capture last bit of anchor
) -> end capturing first token
/g -> end regular expression, add global flag to match all anchors in string


Each call to our anonymous function will receive three tokens as the second, third and fourth arguments, namely arguments[1], arguments[2], arguments[3]:




  • arguments[1] is the entire anchor

  • arguments[2] is the href part

  • arguments[3] is the text inside



We'll use a hack to push these three arguments as a new array into our main matches array. The arguments built-in variable is not a true JavaScript Array, so we'll have to apply the split Array method on it to extract the items we want:



Array.prototype.slice.call(arguments, 1, 4)


This will extract items from arguments starting at index 1 and ending (not inclusive) at index 4.



var input_content = "blah \    <a href=\"http://yahoo.com\">Yahoo</a> \
    blah \
    <a href=\"http://google.com\">Google</a> \
    blah";

var matches = [];

input_content.replace(/[^<]*(<a href="([^"]+)">([^<]+)<\/a>)/g, function () {
matches.push(Array.prototype.slice.call(arguments, 1, 4));
});
alert(matches.join("\n"));


Gives:



<a href="http://yahoo.com">Yahoo</a>,http://yahoo.com,Yahoo
<a href="http://google.com">Google</a>,http://google.com,Google

24 Ekim 2010 Pazar

Başladığım ama şimdilik yarım bırakacağım yıldızlı puanlama

Aslında devam edeceğimden aşırı şüpheliyim çünkü bu işi zaten plugin olarak yapmış olduklarını duyunca uzatmadım ama diğerlerinden mantık birazcık fazla. Ondan bahsedip kodu yapıştırıp çekileyim.


Alt alta 3 div ve bu alttaki iki divinde içlerinde div'lere sarılmış a lar var.
En üstteki divde sağa sola geldikçe yeni puan verildiği için 3. kattaki divin width değeri değişecek böylece mesela 10 üzerinden 7.78 gibi puanlarda verilebilecek. (İDİ)



Konuyla ilgili en saf haliyle eklenti ise :
  1. http://plugins.learningjquery.com/half-star-rating/
  2. http://orkans-tmp.22web.net/star_rating/index.html#main-menu=5
  3. http://www.fyneworks.com/jquery/star-rating/



<style type="text/css">
.divPuanAtutucuGri, .divPuanAtutucuSari, .divPuanAtutucuMavi
{
position: absolute;
}
.divPuanAtutucuSari
{
z-index: 3;
width: 130px;
overflow: hidden;
}
.divPuanAtutucuSari div,.divPuanAtutucuMavi div
{
width: 220px;
}
.divPuanAtutucuMavi
{
z-index: 2;
}
.divPuanAtutucuGri
{
z-index: 1;
}
.divPuanAtutucuGri a, .divPuanAtutucuSari a, .divPuanAtutucuMavi a
{
background: url('images/sprites/yildizlar.png') repeat-x scroll 0 0 #FFFFFF;
height: 20px;
width: 20px;
display: block;
text-indent: -9997px;
float: left;
}
.divPuanAtutucuGri a, .divPuanAtutucuSari a, .divPuanAtutucuMavi a
{
background-position: 0 -40px;
}
.divPuanAtutucuSari a
{
background-position: 0 -60px;
}
.divPuanAtutucuMavi a
{
background-position: 0 -80px;
}
</style>
<script type="text/javascript">
$(function () {
$(".divPuanlama").hover(
function () {
$(".divPuanAtutucuSari").hide();

}, function () {
$(".divPuanAtutucuSari").show();
});

$(".divPuanlama").mousemove(
function (event) {
$("#clientX").html("Left:" + $(this).offset().left + " -- clientX:" + event.clientX);
$("#clientY").html("Top:" + $(this).offset().top + " -- clientY:" + event.clientY);
var x = event.clientX - $(this).offset().left;
$(".divPuanlamaAtutucuMavi div").css("width:" + x+"px");
});
});
</script>

<div class="divPuanlama" style="position: relative; height: 22px; border: 1px solid red;
width: 220px;">
<div class="divPuanAtutucuSari">
<div>
<a>1</a><a>2</a><a>3</a><a>4</a><a>5</a><a>6</a><a>7</a><a>8</a><a>9</a><a>10</a></div>
</div>
<div class="divPuanAtutucuMavi">
<div>
<a>1</a><a>2</a><a>3</a><a>4</a><a>5</a><a>6</a><a>7</a><a>8</a><a>9</a><a>10</a></div>
</div>
<div class="divPuanAtutucuGri">
<a>1</a><a>2</a><a>3</a><a>4</a><a>5</a><a>6</a><a>7</a><a>8</a><a>9</a><a>10</a>
</div>
</div>