Kod Panosu

Kopyala, Yapıştır, Hatırla, Kodla..

Category Archives: JavaScript

JavaScript: Unary + Operator

Eğer siz de benim gibi JavaScript’te string’leri integer’a çevirmek için parseInt fonksiyonuna alternatif bir yazım arıyorsanız tek taraflı (unary) + operatörünü kullanabilirsiniz.

Örnek:

var nums = ['100','300','400','60','40'], 
    num = 0;

for (var i = 0; i < nums.length; i++) {
    num += +nums[i];
}

alert(num);  // 900

Ayrıntılı bilgi: http://xkr.us/articles/javascript/unary-add/

Thanks to: Vitaliy Petrychuk

JavaScript’te Class Inheritance

Hazır kod kullanmayı sevmeyenler için javascript’te en kolay class inheritance yöntemi şu şekilde olur sanırım:

function Person(isDancing){
  this.dancing = isDancing;
  this.dance = function(){
    return this.dancing;
  }
}

function Ninja(){
  this.Person = Person;
  this.Person(false);
  this.swingSword = function(){
    return true;
  }
}

Bu yöntem aşağıdaki testlerden geçer:

var p = new Person(true);
p.dance(); // => true

var n = new Ninja();
n.dance(); // => false
n.swingSword(); // => true

p instanceof Person // => true
n instanceof Ninja  // => true

Ancak bu yöntem prototype chaining’i göz önünde bulundurmadığından polymorphism’i tam olarak desteklemez ve örnek olarak aşağıdaki testten geçemez.

n instanceof Person // => false

Class inheritance’i tam anlamıyla kullanmak ama prototype chaining ile de uğraşmamak istiyorsanız jQuery’nin geliştiricisi John Resig’in “Class” adlı projesini kullanabilirsiniz.

/* Simple JavaScript Inheritance
 * By John Resig http://ejohn.org/
 * MIT Licensed.
 */
// Inspired by base2 and Prototype
(function(){
  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

  // The base Class implementation (does nothing)
  this.Class = function(){};
 
  // Create a new Class that inherits from this class
  Class.extend = function(prop) {
    var _super = this.prototype;
   
    // Instantiate a base class (but only create the instance,
    // don't run the init constructor)
    initializing = true;
    var prototype = new this();
    initializing = false;
   
    // Copy the properties over onto the new prototype
    for (var name in prop) {
      // Check if we're overwriting an existing function
      prototype[name] = typeof prop[name] == "function" &&
        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
        (function(name, fn){
          return function() {
            var tmp = this._super;
           
            // Add a new ._super() method that is the same method
            // but on the super-class
            this._super = _super[name];
           
            // The method only need to be bound temporarily, so we
            // remove it when we're done executing
            var ret = fn.apply(this, arguments);       
            this._super = tmp;
           
            return ret;
          };
        })(name, prop[name]) :
        prop[name];
    }
   
    // The dummy class constructor
    function Class() {
      // All construction is actually done in the init method
      if ( !initializing && this.init )
        this.init.apply(this, arguments);
    }
   
    // Populate our constructed prototype object
    Class.prototype = prototype;
   
    // Enforce the constructor to be what we expect
    Class.prototype.constructor = Class;

    // And make this class extendable
    Class.extend = arguments.callee;
   
    return Class;
  };
})();

Örnek:

var Person = Class.extend({
  init: function(isDancing){
    this.dancing = isDancing;
  },
  dance: function(){
    return this.dancing;
  }
});

var Ninja = Person.extend({
  init: function(){
    this._super( false );
  },
  dance: function(){
    // Call the inherited version of dance()
    return this._super();
  },
  swingSword: function(){
    return true;
  }
});

var p = new Person(true);
p.dance(); // => true

var n = new Ninja();
n.dance(); // => false
n.swingSword(); // => true

// Should all be true
p instanceof Person && p instanceof Class && 
n instanceof Ninja && n instanceof Person && n instanceof Class

Kaynak: http://ejohn.org/blog/simple-javascript-inheritance/

Node.JS İle Yazdığımız Sunucuyu Kodlar Değiştiğinde Otomatik Yenileme

Node.JS ile yazdığımız ör. http server, tcp server gibi sunucular kaynak kodunda değişiklik yaptığımız takdirde yeniden başlatılmalıdır. Ancak nodemon adlı modül sayesinde sunucumuzu kaynak kodu değiştiğinde otomatik olarak yeniden başlatabiliriz. Bu da development aşamasında büyük kolaylık sağlar

Nodemon’u NPM aracılığıyla “global” seçeneğiyle kuruyoruz ki nodemon projemize dahil olmasın:

npm install nodemon -g

Nodemon’a uygulamamızı başlatmasını söylüyoruz. Örnek:

nodemon ./server.js localhost 8080

Nodemon artık projemizi ilgilendiren dosyalardaki değişikliği otomaik olarak takip edecek ve değişiklikleri tespit ettiğinden uygulamamızı yeniden başlatacak.

NPM’i Kullanmadan Node.JS Modülleri Kurma

NPM çalışmıyorsa yüklenmesi gereken modüller için:

  1. NODE_PATH adlı bir ortam değişkeni oluşturup değer olarak “C:\Program Files\nodejs\node_modules” veriyoruz.
  2. http://registry.npmjs.org/%5Bmodul_adi%5D adresine gidiyoruz. Ör: http://registry.npmjs.org/express
  3. Sayfanın en altında modül yazarının github adresinden modülü indiriyoruz.
  4. Bulamazsak en güncel versiyon numaralı tarball’u (*.tgz) indiriyoruz.
  5. Arşivi C:\Program Files\nodejs\node_modules adresine açıp klasörün adını modülün adına çeviriyoruz.

NPM’in Registry URL’ini Değiştirme

npm config set registry "http://registry.npmjs.org/"

Bu komut sayesinde normalde https://registry.npmjs.org/ olan nmp registry adresini http’ye çevirerek sertifika sorunlarından kurtulabilirsiniz.