var functionName = function () {} vs function functionName () {}


Al─▒nan cevaba git


K─▒sa s├╝re ├Ânce ba┼čkas─▒n─▒n JavaScript kodunu korumaya ba┼člad─▒m. Hatalar─▒ d├╝zeltiyorum, ├Âzellikler ekliyorum ve ayr─▒ca kodu d├╝zeltmeye ve daha tutarl─▒ hale getirmeye ├žal─▒┼č─▒yorum.

├ľnceki geli┼čtirici, i┼člevleri bildirmek i├žin iki yol kullan─▒yor ve bunun arkas─▒nda bir sebep olup olmad─▒─č─▒n─▒ ├ž├Âzemiyorum.

─░ki yol:

 var functionOne = function() {
    // Some code
};
 
 function functionTwo() {
    // Some code
}
 

Bu iki farkl─▒ y├Ântemi kullanman─▒n nedenleri ve her birinin avantaj ve dezavantajlar─▒ nelerdir? Bir y├Ântemle di─čeriyle yap─▒lamayan bir ┼čey yap─▒labilir mi?


6604









Cevap say─▒s─▒n─▒ say: 30






Aradaki fark, functionOne bir fonksiyon ifadesidir ve yaln─▒zca bu sat─▒ra ula┼č─▒ld─▒─č─▒nda tan─▒mlan─▒r, oysa functionTwo bir fonksiyon bildirimidir ve ├ževreleyen fonksiyon veya komut dosyas─▒ ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ( kald─▒rma nedeniyle ) tan─▒mlan─▒r.

├ľrne─čin, bir i┼člev ifadesi:

 // TypeError: functionOne is not a function
functionOne();

var functionOne = function() {
  console.log("Hello!");
}; 

Ve bir i┼člev bildirimi:

 // Outputs: "Hello!"
functionTwo();

function functionTwo() {
  console.log("Hello!");
} 

Bu ayr─▒ca, i┼člev bildirimlerini kullanarak ko┼čullu olarak i┼člevleri tan─▒mlayamayaca─č─▒n─▒z anlam─▒na gelir:

 if (test) {
   // Error or misbehavior
   function functionThree() { doSomething(); }
}
 

Yukar─▒dakiler asl─▒nda de─čerinden functionThree ba─č─▒ms─▒z olarak tan─▒mlamaktad─▒r test - e─čer use strict ge├žerli de─čilse , bu durumda sadece bir hata do─čurur.


4885


2008-12-03





├ľncelikle Greg'i d├╝zeltmek istiyorum: function abc(){} ├žok kapsaml─▒ - isim abc bu tan─▒m─▒n kar┼č─▒la┼čt─▒─č─▒ kapsamda tan─▒mland─▒. ├ľrnek:

 function xyz(){
  function abc(){};
  // abc is defined here...
}
// ...but not here
 

─░kincisi, her iki stili de birle┼čtirmek m├╝mk├╝nd├╝r:

 var xyz = function abc(){};
 

xyz her zamanki gibi abc tan─▒mlanacak, t├╝m taray─▒c─▒larda tan─▒ms─▒z ama Internet Explorer - tan─▒mlanm─▒┼č olmas─▒na g├╝venmiyor. Ancak bedeninde tan─▒mlanacakt─▒r:

 var xyz = function abc(){
  // xyz is visible here
  // abc is visible here
}
// xyz is visible here
// abc is undefined here
 

─░┼člevleri t├╝m taray─▒c─▒larda takma isimlendirmek istiyorsan─▒z, bu t├╝r bildirimleri kullan─▒n:

 function abc(){};
var xyz = abc;
 

Bu durumda, her ikisi de xyz ve abc ayn─▒ nesnenin di─čer ad─▒d─▒r:

 console.log(xyz === abc); // prints "true"
 

Birle┼čtirilmi┼č stili kullanman─▒n en zorlay─▒c─▒ nedenlerinden biri, i┼člev nesnelerinin "name" niteli─čidir ( Internet Explorer taraf─▒ndan desteklenmez ). Temelde gibi bir i┼člev tan─▒mlad─▒─č─▒n─▒zda

 function abc(){};
console.log(abc.name); // prints "abc"
 

ad─▒ otomatik olarak atan─▒r. Ama onu tan─▒mlad─▒─č─▒n zaman

 var abc = function(){};
console.log(abc.name); // prints ""
 

ad─▒ bo┼č - biz isimsiz bir i┼člev yaratt─▒k ve onu bir de─či┼čkene verdik.

Birle┼čtirilmi┼č stili kullanman─▒n bir ba┼čka iyi nedeni, d─▒┼č kullan─▒c─▒lar i├žin uzun bir ├želi┼čkili ad sa─člarken, kendisine at─▒fta bulunmak i├žin k─▒sa bir i├ž ad kullanmakt─▒r:

 // Assume really.long.external.scoped is {}
really.long.external.scoped.name = function shortcut(n){
  // Let it call itself recursively:
  shortcut(n - 1);
  // ...
  // Let it pass itself as a callback:
  someFunction(shortcut);
  // ...
}
 

Yukar─▒daki ├Ârnekte ayn─▒ ┼čeyi harici bir adla yapabiliriz, ancak ├žok hantal olacakt─▒r (ve daha yava┼č).

(Kendine g├Ânderme yapman─▒n ba┼čka bir yolu arguments.callee , hala nispeten uzun olan ve kat─▒ modda desteklenmeyen kullan─▒m─▒d─▒r.)

Derinlerde, JavaScript her iki ifadeyi de farkl─▒ ┼čekilde ele al─▒r. Bu bir i┼člev bildirimidir:

 function abc(){}
 

abc burada her yerde ge├žerli kapsamda tan─▒mlanm─▒┼čt─▒r:

 // We can call it here
abc(); // Works

// Yet, it is defined down there.
function abc(){}

// We can call it again
abc(); // Works
 

Ayr─▒ca, bir return a├ž─▒klama yoluyla kald─▒rd─▒ :

 // We can call it here
abc(); // Works
return;
function abc(){}
 

Bu bir fonksiyon ifadesidir:

 var xyz = function(){};
 

xyz burada atama noktas─▒ndan tan─▒mlan─▒r:

 // We can't call it here
xyz(); // UNDEFINED!!!

// Now it is defined
xyz = function(){}

// We can call it here
xyz(); // works
 

─░┼člev bildirimi - i┼člev ifadesi, Greg taraf─▒ndan g├Âsterilen bir fark─▒n olmas─▒n─▒n ger├žek nedenidir.

E─členceli ger├žek:

 var xyz = function abc(){};
console.log(xyz.name); // Prints "abc"
 

┼×ahsen, ben "i┼člev ifadesi" bildirimini tercih ederim ├ž├╝nk├╝ bu ┼čekilde g├Âr├╝n├╝rl├╝─č├╝ kontrol edebiliyorum. Fonksiyonu tan─▒mlad─▒─č─▒mda

 var abc = function(){};
 

Fonksiyonu yerel olarak tan─▒mlad─▒─č─▒m─▒ biliyorum. Fonksiyonu tan─▒mlad─▒─č─▒mda

 abc = function(){};
 

Global olarak tan─▒mlad─▒─č─▒m─▒ abc , kapsam zincirinde hi├žbir yerde tan─▒mlamamam─▒ sa─člad─▒─č─▒m─▒ biliyorum . Bu tan─▒m tarz─▒, i├žinde kullan─▒ld─▒─č─▒nda bile dayan─▒kl─▒d─▒r eval() . Tan─▒m─▒ yaparken

 function abc(){};
 

Ba─člama ba─čl─▒ olarak de─či┼čir ve ├Âzellikle nerede tan─▒mland─▒─č─▒n─▒ tahmin etmenizi sa─člayabilir, ├Âzellikle de eval() - cevap: Taray─▒c─▒ya ba─čl─▒d─▒r.


1902







─░┼člevler yaratan standart formlardaki ├Âzet: (Aslen ba┼čka bir soru i├žin yaz─▒lm─▒┼čt─▒r, ancak kanonik soruya ta┼č─▒nd─▒ktan sonra uyarlanm─▒┼čt─▒r.)

┼×artlar─▒:

H─▒zl─▒ liste:

  • ─░┼člev Beyan─▒

  • "Anonim" function ─░fadesi (terime ra─čmen bazen adlarla i┼člevler olu┼čturur)

  • Adland─▒r─▒lm─▒┼č function ─░fade

  • Accessor ─░┼člev Ba┼člat─▒c─▒ (ES5 +)

  • Ok ─░┼člev ─░fadesi (ES2015 +) (ads─▒z i┼člev ifadeleri gibi a├ž─▒k bir ad i├žermez, ancak adlarla i┼člevler olu┼čturabilir)

  • Nesne Ba┼člat─▒c─▒s─▒nda Y├Ântem Bildirimi (ES2015 +)

  • Yap─▒c─▒ ve Y├Ântem A├ž─▒klamalar─▒ class (ES2015 +)

─░┼člev Beyan─▒

─░lk bi├žim, ┼čuna benzeyen bir i┼člev bildirimidir :

 function x() {
    console.log('x');
}
 

Bir i┼člev bildirimi bir bildiridir ; bu bir ifade veya ifade de─čil. Bu nedenle, onu takip etmiyorsunuz ; (her ne kadar zarars─▒z olsa da).

Y├╝r├╝tme, herhangi bir ad─▒m ad─▒m kod y├╝r├╝t├╝lmeden ├Ânce g├Âr├╝nd├╝─č├╝ i├žeri─če girdi─činde bir i┼člev bildirimi i┼členir . Olu┼čturdu─ču i┼čleve uygun bir ad verilir ( x yukar─▒daki ├Ârnekte) ve bu ad, bildirimin g├Âr├╝nd├╝─č├╝ kapsamda belirtilir.

Ayn─▒ ba─člamda ad─▒m ad─▒m kodlardan ├Ânce i┼člendi─činden, bunun gibi ┼čeyler yapabilirsiniz:

 x(); // Works even though it's above the declaration
function x() {
    console.log('x');
}
 

ES2015 kadar, spec gibi bir kontrol yap─▒s─▒ i├žinde bir i┼člevi bildirimi koyarsan─▒z bir JavaScript motoru ne yapmas─▒ gerekti─čini kapa─č─▒ yoktu try , if , switch , while b├Âyle, vb:

 if (someCondition) {
    function foo() {    // <===== HERE THERE
    }                   // <===== BE DRAGONS
}
 

Ad─▒m ad─▒m kod ├žal─▒┼čt─▒r─▒lmadan ├Ânce i┼člendiklerinden , bir kontrol yap─▒s─▒nda ne yapacaklar─▒n─▒ bilmek zor.

Bunu yapmak ES2015'e kadar belirtilmemi┼č olmas─▒na ra─čmen , bloklardaki i┼člev bildirimlerini desteklemek i├žin izin verilen bir uzant─▒yd─▒ . Ne yaz─▒k ki (ve ka├ž─▒n─▒lmaz olarak), farkl─▒ motorlar farkl─▒ ┼čeyler yapt─▒.

ES2015'ten itibaren ┼čartnamede ne yap─▒lmas─▒ gerekti─či yaz─▒yor. Asl─▒nda, yap─▒lacak ├╝├ž ayr─▒ ┼čey verir:

  1. Gev┼ček modda bir web taray─▒c─▒s─▒nda de─čilse , JavaScript motorunun bir ┼čey yapmas─▒ gerekiyordu
  2. Bir web taray─▒c─▒s─▒nda gev┼ček modda ise, JavaScript motorunun ba┼čka bir ┼čey yapmas─▒ gerekiyordu
  3. ─░├žinde ise kat─▒ modda (taray─▒c─▒ veya de─čil), JavaScript motoru hen├╝z ba┼čka bir ┼čey yapmak gerekiyordu

Gev┼ček modlar i├žin kurallar zordur, ancak kat─▒ modda, bloklardaki i┼člev bildirimleri kolayd─▒r: Blo─ča yereldirler (ES2015'te de yeni olan blok kapsam─▒na sahiptirler) ve en ├╝ste kald─▒r─▒l─▒rlar. blo─čun Yani:

 "use strict";
if (someCondition) {
    foo();               // Works just fine
    function foo() {
    }
}
console.log(typeof foo); // "undefined" (`foo` is not in scope here
                         // because it's not in the same block)
 

"Anonim" function ─░fadesi

─░kinci ortak form, isimsiz bir fonksiyon ifadesi olarak adland─▒r─▒l─▒r :

 var y = function () {
    console.log('y');
};
 

T├╝m ifadeler gibi, kodun ad─▒m ad─▒m y├╝r├╝t├╝lmesine ula┼č─▒ld─▒─č─▒nda de─čerlendirilir.

ES5'te, bunun yaratt─▒─č─▒ i┼člevin ad─▒ yoktur (ads─▒zd─▒r). ES2015'te, m├╝mk├╝nse ba─člamdan ├ž─▒kartarak fonksiyona bir ad verilir. Yukar─▒daki ├Ârnekte, isim olacakt─▒r y . ─░┼člev bir ├Âzellik ba┼člat─▒c─▒n─▒n de─čeri oldu─čunda benzer bir ┼čey yap─▒l─▒r. (Bunun ne zaman ger├žekle┼čti─či ve kurallar─▒n ayr─▒nt─▒lar─▒ SetFunctionName i├žin , teknik ├Âzelliklerde arama yap─▒n  - her yerde g├Âr├╝n├╝r .)

Adland─▒r─▒lm─▒┼č function ─░fade

├ť├ž├╝nc├╝ bi├žim, adland─▒r─▒lm─▒┼č bir i┼člev ifadesidir ("NFE"):

 var z = function w() {
    console.log('zw')
};
 

Bunun yaratt─▒─č─▒ i┼člev uygun bir isme sahiptir ( w bu durumda). T├╝m ifadeler gibi, kodun ad─▒m ad─▒m y├╝r├╝t├╝lmesinde de bu de─čerlendirilir. Fonksiyon ad─▒d─▒r olmayan ifadesi g├Âr├╝nd├╝─č├╝ kapsam─▒na dahil; isim , fonksiyonun i├žinde yer almaktad─▒r:

 var z = function w() {
    console.log(typeof w); // "function"
};
console.log(typeof w);     // "undefined"
 

NFE'lerin JavaScript uygulamalar─▒ i├žin s─▒k s─▒k bir hata kayna─č─▒ oldu─čuna dikkat edin. ├ľrne─čin IE8 ve ├Ânceki s├╝r├╝mler, NFE'leri tamamen yanl─▒┼č kullan─▒r ve iki farkl─▒ anda iki farkl─▒ fonksiyon olu┼čturur. Safari'nin ilk s├╝r├╝mlerinde de sorunlar vard─▒. ─░yi haber ┼ču ki, taray─▒c─▒lar─▒n ┼ču anki s├╝r├╝mleri (IE9 ve ├╝st├╝, mevcut Safari) art─▒k bu sorunlara sahip de─čil. (Ancak bu yaz─▒dan dolay─▒, ne yaz─▒k ki, IE8 yayg─▒n olarak kullan─▒lmaya devam etmektedir ve bu nedenle NFE'leri genel olarak web i├žin kodla kullanmak hala sorunludur.)

Accessor ─░┼člev Ba┼člat─▒c─▒ (ES5 +)

Bazen i┼člevler b├╝y├╝k ├Âl├ž├╝de fark edilmeden gizlice girebilir; Bununla durum eri┼čimci fonksiyonlar . ─░┼čte bir ├Ârnek:

 var obj = {
    value: 0,
    get f() {
        return this.value;
    },
    set f(v) {
        this.value = v;
    }
};
console.log(obj.f);         // 0
console.log(typeof obj.f);  // "number"
 

Fonksiyonu kulland─▒─č─▒mda kullanmad─▒─č─▒m─▒ unutmay─▒n () ! Bunun nedeni bir m├╝lk i├žin eri┼čim i┼člevi . ├ľzelli─či normal ┼čekilde al─▒yoruz ve ayarl─▒yoruz, ancak perde arkas─▒na i┼člev deniyor.

Ayr─▒ca eri┼čimcisinin i┼člevleri olu┼čturabilir Object.defineProperty , Object.defineProperties ve daha az bilinen ikinci arg├╝man Object.create .

Ok ─░┼člev ─░fadesi (ES2015 +)

ES2015 bize ok i┼člevini getiriyor . ─░┼čte bir ├Ârnek:

 var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); // 2, 4, 6
 

G├Ârd├╝n n => n * 2 i├žinde ┼čey saklan─▒rken map() ├ža─čr─▒s─▒? Bu bir fonksiyon.

Ok fonksiyonlar─▒ hakk─▒nda bir ka├ž ┼čey:

  1. Onlar─▒n kendileri yok this . Bunun yerine, yak─▒n ├╝zerinde this onlar tan─▒mlanm─▒┼člarsa ba─člam─▒n. (Ayr─▒ca kapan─▒rlar arguments ve ilgili olduklar─▒ yerde super .) Bu, this i├žlerindekilerin this yarat─▒ld─▒klar─▒ yerle ayn─▒ oldu─ču ve de─či┼čtirilemeyece─či anlam─▒na gelir.

  2. Yukar─▒dakileri fark etti─činiz gibi, anahtar kelimeyi kullanmazs─▒n─▒z function ; bunun yerine kullan─▒yorsunuz => .

Yukar─▒daki n => n * 2 ├Ârnek bunlardan biri. ─░┼člevi ge├žmek i├žin birden fazla arg├╝man varsa, parens kullan─▒rs─▒n─▒z:

 var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); // 0, 2, 6
 

( Array#map Girdiyi ilk arg├╝man olarak ve dizini ikinci olarak ge├žirdi─čini unutmay─▒n .)

Her iki durumda da, fonksiyonun g├Âvdesi sadece bir ifadedir; i┼člevin d├Ân├╝┼č de─čeri otomatik olarak bu ifadenin sonucu olacakt─▒r (a├ž─▒k bir kullan─▒m kullanmazs─▒n─▒z return ).

Tek bir ifadeden daha fazlas─▒n─▒ yap─▒yorsan─▒z , normal olarak kullan─▒n {} ve a├ž─▒k return (bir de─čer d├Ând├╝rmeniz gerekirse):

 var a = [
  {first: "Joe", last: "Bloggs"},
  {first: "Albert", last: "Bloggs"},
  {first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
  var rv = a.last.localeCompare(b.last);
  if (rv === 0) {
    rv = a.first.localeCompare(b.first);
  }
  return rv;
});
console.log(JSON.stringify(a));
 

Olmayan bi├žimi, { ... } bir ile bir ok fonksiyonu olarak adland─▒r─▒l─▒r sentezleme g├Âvdesi ya da k─▒sa g├Âvde . (Ayr─▒ca: K─▒sa ve ├Âz bir ok i┼člevi.) { ... } Bedeni tan─▒mlayan i┼člev i┼člev g├Âvdeli bir ok i┼člevidir . (Ayr─▒ca: Ayr─▒nt─▒l─▒ bir ok i┼člevi.)

Nesne Ba┼člat─▒c─▒s─▒nda Y├Ântem Bildirimi (ES2015 +)

ES2015, y├Ântem tan─▒m─▒ olarak adland─▒r─▒lan bir i┼čleve ba┼čvuran bir ├Âzellik bildirmenin daha k─▒sa bir bi├žimine izin verir ; bu gibi g├Âr├╝n├╝yor:

 var o = {
    foo() {
    }
};
 

ES5 ve ├Ânceki s├╝r├╝mlerde neredeyse e┼čde─čer:

 var o = {
    foo: function foo() {
    }
};
 

Aradaki fark (ayr─▒nt─▒land─▒rma d─▒┼č─▒nda) bir y├Ântemin kullanabilece─či super ancak bir fonksiyonun kullanamayaca─č─▒d─▒r. ├ľrne─čin, valueOf y├Ântem s├Âzdizimini kullanarak tan─▒mlayan (s├Âyleyen) bir nesneniz olsayd─▒ super.valueOf() , de─čeri Object.prototype.valueOf geri almak i├žin kullanabilirdi (muhtemelen bununla ba┼čka bir ┼čey yapmadan ├Ânce), Object.prototype.valueOf.call(this) bunun yerine ES5 s├╝r├╝m├╝n├╝n yapmas─▒ gerekirdi .

Y├Ântem bu nesne ge├žici ise, bu ┼čekilde (mesela, i├žine ge├žerken, bu tan─▒mland─▒ nesnesine bir referans vard─▒r Bu da arac─▒ Object.assign , kaynak nesnelerden biri olarak), y├Ântem s├Âz dizimi olabilir nesnenin muhafaza edildi─či anlam─▒na aksi takdirde bellekte ├ž├Âp toplanabiliyordu (e─čer JavaScript motoru bu durumu alg─▒lam─▒yorsa ve y├Ântemlerden hi├žbiri kullanm─▒yorsa kullanmazsa super ).

Yap─▒c─▒ ve Y├Ântem A├ž─▒klamalar─▒ class (ES2015 +)

ES2015, class bildirilen yap─▒c─▒lar ve y├Ântemler dahil , bize s├Âzdizimi getiriyor :

 class Person {
    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullName() {
        return this.firstName + " " + this.lastName;
    }
}
 

Yukar─▒da iki i┼člev bildirimi vard─▒r: Biri ad─▒ alan kurucu, Person biri i├žin getFullName atanan i┼člev i├žin Person.prototype .


605







Global ba─člam hakk─▒nda konu┼čmak gerekirse, hem var ifade hem FunctionDeclaration de sonunda global nesne ├╝zerinde silinemez bir ├Âzellik yaratacakt─▒r , ancak her ikisinin de de─čerinin ├╝zerine yaz─▒labilir .

─░ki yol aras─▒ndaki ince fark, De─či┼čken ├ľrnekleme i┼člemi ├žal─▒┼čt─▒─č─▒nda (ger├žek kod y├╝r├╝t├╝lmesinden ├Ânce) bildirilen t├╝m tan─▒mlay─▒c─▒lar─▒n var ba┼člang─▒├ž ÔÇőÔÇődurumuna getirilece─či undefined ve FunctionDeclaration ├Ârne─čin ┼ču andan itibaren kullan─▒labilecekleri:

  alert(typeof foo); // 'function', it's already available
 alert(typeof bar); // 'undefined'
 function foo () {}
 var bar = function () {};
 alert(typeof bar); // 'function'
 

Yap─▒lan atama bar FunctionExpression ├žal─▒┼čma zaman─▒na kadar ger├žekle┼čir.

Bir FunctionDeclaration de─či┼čken taraf─▒ndan yarat─▒lan global bir ├Âzellik , de─či┼čken bir de─čer gibi problemsiz olarak ├╝zerine yaz─▒labilir, ├Ârne─čin:

  function test () {}
 test = null;
 

─░ki ├Ârne─činiz aras─▒ndaki bir di─čer belirgin fark, ilk i┼člevin bir isme sahip olmamas─▒, ikincisi de hata ay─▒klama i┼čleminde ger├žekten yararl─▒ olabilecek (yani bir ├ža─čr─▒ y─▒─č─▒n─▒n─▒ denetleme) sahip olmas─▒d─▒r.

D├╝zenlenen ilk ├Ârne─činiz hakk─▒nda ( foo = function() { alert('hello!'); }; ), bildirilmemi┼č bir ├Âdevdir, var anahtar kelimeyi her zaman kullanman─▒z─▒ ┼čiddetle tavsiye ederim .

Atama ile, ifade olmadan, var ba┼čvurulan tan─▒mlay─▒c─▒ kapsam zincirinde bulunmazsa , global nesnenin silinebilir bir ├Âzelli─či olur .

Ayr─▒ca, bildirilmemi┼č atamalarda S─▒k─▒ Mod ReferenceError alt─▒nda ECMAScript 5 kullan─▒l─▒r .http://dmitrysoshnikov.com/ecmascript/es5-chapter-2-strict-mode/

Okunmal─▒:

Not : Bu cevap, OP ile ilgili temel ┼č├╝phenin ve yanl─▒┼č anla┼č─▒lman─▒n, tan─▒mlay─▒c─▒lar─▒n a ile bildirildi─či ┼čeklinde yaz─▒ld─▒─č─▒ , ba┼čka bir soru ile birle┼čtirilmi┼čtir FunctionDeclaration .


138


2010-08-08





Oraya g├Ânderdi─činiz iki kod par├žac─▒─č─▒, hemen hemen t├╝m ama├žlar i├žin ayn─▒ ┼čekilde davranacak.

Ancak, davran─▒┼čtaki fark, ilk de─či┼čken ( var functionOne = function() {} ) ile, bu fonksiyonun ancak koddaki o noktadan sonra ├ža─čr─▒labilmesidir.

─░kinci de─či┼čken ( function functionTwo() ) ile i┼člev, i┼člevin bildirildi─či yerde ├žal─▒┼čan kod i├žin kullan─▒labilir.

Bunun nedeni, ilk de─či┼čkende, i┼člevin foo ├žal─▒┼čma zaman─▒nda de─či┼čkene atanmas─▒d─▒r . ─░kincisinde, i┼člev foo ayr─▒┼čt─▒rma zaman─▒nda bu tan─▒mlay─▒c─▒ya atan─▒r .

Daha fazla teknik bilgi

JavaScript'in fonksiyonlar─▒ tan─▒mlaman─▒n ├╝├ž yolu vard─▒r.

  1. ─░lk pasaj─▒n─▒z bir i┼člev ifadesi g├Âsteriyor . Bu, bir i┼člev olu┼čturmak i├žin "i┼člev" i┼člecini kullanmay─▒ i├žerir - bu i┼člecin sonucu herhangi bir de─či┼čkende veya nesne ├Âzelli─činde saklanabilir. ─░┼člev ifadesi bu ┼čekilde g├╝├žl├╝d├╝r. ─░┼člev ifadesine genellikle "ads─▒z i┼člev" denir, ├ž├╝nk├╝ bir ad─▒ olmas─▒ gerekmez,
  2. ─░kinci ├Ârne─činiz bir i┼člev bildirimidir . Bu, bir i┼člev olu┼čturmak i├žin "function" deyimini kullan─▒r . ─░┼člev ayr─▒┼čt─▒rma zaman─▒nda kullan─▒labilir duruma gelir ve bu kapsamda herhangi bir yerde ├ža─čr─▒labilir. Daha sonra bir de─či┼čken veya nesne ├Âzelli─činde saklayabilirsiniz.
  3. Bir i┼člevi tan─▒mlaman─▒n ├╝├ž├╝nc├╝ yolu, as─▒l mesaj─▒n─▒zda g├Âsterilmeyen "Function ()" yap─▒c─▒s─▒d─▒r . Bu eval() , kendi sorunlar─▒ olan ayn─▒ ┼čekilde ├žal─▒┼čt─▒─č─▒ gibi kullan─▒lmas─▒ tavsiye edilmez .

120







Greg'in cevab─▒na daha iyi bir a├ž─▒klamahttps://stackoverflow.com/a/336868/2351696

 functionTwo();
function functionTwo() {
}
 

Neden hata yok? Her zaman ifadelerin yukar─▒dan a┼ča─č─▒ya do─čru y├╝r├╝t├╝ld├╝─č├╝ bize ├Â─čretildi (??)

Çünkü:

─░┼člev bildirimleri ve de─či┼čken bildirimleri hoisted , JavaScript yorumlay─▒c─▒s─▒ taraf─▒ndan her zaman g├Âr├╝nmez bir ┼čekilde i├žerdikleri kapsam─▒n ├╝st├╝ne ta┼č─▒n─▒r . ─░┼člev parametreleri ve dille tan─▒mlanm─▒┼č adlar a├ž─▒k├žas─▒ zaten orada. ben kiraz

Bu, ┼č├Âyle bir kod anlam─▒na gelir:

 functionOne();                  ---------------      var functionOne;
                                | is actually |      functionOne();
var functionOne = function(){   | interpreted |-->
};                              |    like     |      functionOne = function(){
                                ---------------      };
 

Bildirimlerin atama k─▒sm─▒n─▒n kald─▒r─▒lmad─▒─č─▒na dikkat edin. Sadece isim kald─▒r─▒ld─▒.

Ancak, i┼člev bildirimlerinde, t├╝m i┼člev g├Âvdesi de kald─▒r─▒l─▒r :

 functionTwo();              ---------------      function functionTwo() {
                            | is actually |      };
function functionTwo() {    | interpreted |-->
}                           |    like     |      functionTwo();
                            ---------------
 

99







Di─čer yorumcular, yukar─▒daki iki de─či┼čkenin anlamsal fark─▒n─▒ zaten ele ald─▒lar. Stilistik bir fark─▒ not etmek istedim: Yaln─▒zca "atama" varyasyonu ba┼čka bir nesnenin ├Âzelli─čini ayarlayabilir.

S─▒k s─▒k ┼č├Âyle bir desenle JavaScript mod├╝lleri in┼ča ediyorum:

 (function(){
    var exports = {};

    function privateUtil() {
            ...
    }

    exports.publicUtil = function() {
            ...
    };

    return exports;
})();
 

Bu d├╝zende, genel i┼člevleriniz t├╝m atamalar─▒ kullan─▒r, ├Âzel i┼člevleriniz de bildirim kullan─▒r.

(Ayr─▒ca, bildirimin yasaklamas─▒na ra─čmen ataman─▒n ifadeden sonra noktal─▒ virg├╝l gerektirmesi gerekti─čini unutmay─▒n.)


88







─░lk y├Ântemin ikinciye ne zaman tercih edilece─čine dair bir ├Ârnek, bir i┼člevin ├Ânceki tan─▒mlar─▒n─▒ ge├žersiz k─▒lmaktan ka├ž─▒nman─▒z gerekti─čine ili┼čkindir.

─░le

 if (condition){
    function myfunction(){
        // Some code
    }
}
 

, bu tan─▒m─▒ myfunction , ayr─▒┼čt─▒rma zaman─▒nda yap─▒laca─č─▒ndan ├Ânceki tan─▒mlar─▒ ge├žersiz k─▒lar.

S├╝re

 if (condition){
    var myfunction = function (){
        // Some code
    }
}
 

do─čru zamanda myfunction sadece condition kar┼č─▒land─▒─č─▒nda tan─▒mlayan i┼či yapar .


75







├ľnemli bir neden, ad alan─▒n─▒z─▒n "K├Âk├╝" olarak yaln─▒zca bir de─či┼čken eklemektir ...

 var MyNamespace = {}
MyNamespace.foo= function() {

}
 

veya

 var MyNamespace = {
  foo: function() {
  },
  ...
}
 

─░sim alan─▒ i├žin pek ├žok teknik var. Mevcut JavaScript mod├╝llerinin bollu─ču ile daha ├Ânemli hale geldi.

Ayr─▒ca bkz . JavaScript'te bir ad alan─▒n─▒ nas─▒l ilan ederim?


60


2010-08-08





Kald─▒rma , JavaScript yorumlay─▒c─▒s─▒n─▒n t├╝m de─či┼čken ve i┼člev bildirimlerini ge├žerli kapsam─▒n en ├╝st├╝ne ta┼č─▒ma eylemidir.

Ancak, yaln─▒zca ger├žek beyanlar kald─▒r─▒l─▒r. g├Ârevlerini olduklar─▒ yerde b─▒rakarak.

  • de─či┼čkenin / ─░┼člevinin sayfa i├žinde bildirdi─či geneldir, o sayfada herhangi bir yere eri┼čebilir.
  • de─či┼čkenin / ─░┼člev i├žinde bildirilen ─░┼člevlerin yerel kapsam─▒ vard─▒r. i┼člev g├Âvdesi (kapsam─▒) i├žinde eri┼čilebildiklerini / eri┼čilebildiklerini, i┼člev g├Âvdesinin d─▒┼č─▒nda kullan─▒lamad─▒klar─▒n─▒ g├Âsterir.

De─či┼čken

Javascript gev┼ček yaz─▒lm─▒┼č bir dil denir. Bu, Javascript de─či┼čkenlerinin herhangi bir Veri T├╝r├╝n├╝n de─čerini tutabilece─či anlam─▒na gelir . Javascript, ├žal─▒┼čma zaman─▒ s─▒ras─▒nda sa─članan de─čere / de─či┼čime g├Âre de─či┼čken t├╝r├╝n├╝ de─či┼čtirmeyi otomatik olarak ├Ânemser.

 global_Page = 10;                                               var global_Page;      ┬ź undefined
    ┬ź Integer literal, Number Type.   -------------------       global_Page = 10;     ┬ź Number         
global_Page = 'Yash';                 |   Interpreted   |       global_Page = 'Yash'; ┬ź String
    ┬ź String literal, String Type.    ┬ź       AS        ┬ź       global_Page = true;   ┬ź Boolean 
var global_Page = true;               |                 |       global_Page = function (){          ┬ź function
    ┬ź Boolean Type                    -------------------                 var local_functionblock;  ┬ź undefined
global_Page = function (){                                                local_functionblock = 777;┬ź Number
    var local_functionblock = 777;                              };  
    // Assigning function as a data.
};  
 

fonksiyon

 function Identifier_opt ( FormalParameterList_opt ) { 
      FunctionBody | sequence of statements

      ┬ź return;  Default undefined
      ┬ź return 'some data';
}
 
  • Sayfa i├žinde bildirilen i┼člevler, genel eri┼čime sahip sayfan─▒n ├╝st├╝ne getirilir.
  • ─░┼člev blo─čunun i├žinde bildirilen i┼člevler, blo─čun ├╝st├╝ne kald─▒r─▒l─▒r.
  • Fonksiyonun varsay─▒lan d├Ân├╝┼č de─čeri ' tan─▒ms─▒z ', De─či┼čken bildirim varsay─▒lan de─čeri de 'tan─▒ms─▒z'

     Scope with respect to function-block global. 
    Scope with respect to page undefined | not available.
     

─░┼člev Beyan─▒

 function globalAccess() {                                  function globalAccess() {      
}                                  -------------------     }
globalAccess();                    |                 |     function globalAccess() { ┬ź Re-Defined / overridden.
localAccess();                     ┬ź   Hoisted  As   ┬ź         function localAccess() {
function globalAccess() {          |                 |         }
     localAccess();                -------------------         localAccess(); ┬ź function accessed with in globalAccess() only.
     function localAccess() {                              }
     }                                                     globalAccess();
}                                                          localAccess(); ┬ź ReferenceError as the function is not defined
 

─░┼člev ─░fadesi

         10;                 ┬ź literal
       (10);                ┬ź Expression                (10).toString() -> '10'
var a;                      
    a = 10;                 ┬ź Expression var              a.toString()  -> '10'
(function invoke() {        ┬ź Expression Function
 console.log('Self Invoking');                      (function () {
});                                                               }) () -> 'Self Invoking'

var f; 
    f = function (){        ┬ź Expression var Function
    console.log('var Function');                                   f ()  -> 'var Function'
    };
 

De─či┼čkene atanan i┼člev ├ľrnek:

 (function selfExecuting(){
    console.log('IIFE - Immediately-Invoked Function Expression');
}());

var anonymous = function (){
    console.log('anonymous function Expression');
};

var namedExpression = function for_InternalUSE(fact){
    if(fact === 1){
        return 1;
    }

    var localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    //return; //undefined.
    return fact * for_InternalUSE( fact - 1);   
};

namedExpression();
globalExpression();
 

javascript olarak yorumland─▒

 var anonymous;
var namedExpression;
var globalExpression;

anonymous = function (){
    console.log('anonymous function Expression');
};

namedExpression = function for_InternalUSE(fact){
    var localExpression;

    if(fact === 1){
        return 1;
    }
    localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    return fact * for_InternalUSE( fact - 1);    // DEFAULT UNDEFINED.
};

namedExpression(10);
globalExpression();
 

─░┼člev bildirimini kontrol edebilir, farkl─▒ taray─▒c─▒lar ├╝zerinden ifade testi kullanabilirsiniz. jsperf Test Runner


ES5 Yap─▒c─▒ ─░┼člev S─▒n─▒flar─▒ : Function.prototype.bind kullan─▒larak olu┼čturulan i┼člev nesneleri

JavaScript, i┼člevleri birinci s─▒n─▒f nesneler olarak g├Âr├╝r; bu nedenle, bir nesne olarak bir i┼čleve ├Âzellikler atayabilirsiniz.

 function Shape(id) { // Function Declaration
    this.id = id;
};
    // Adding a prototyped method to a function.
    Shape.prototype.getID = function () {
        return this.id;
    };
    Shape.prototype.setID = function ( id ) {
        this.id = id;
    };

var expFn = Shape; // Function Expression

var funObj = new Shape( ); // Function Object
funObj.hasOwnProperty('prototype'); // false
funObj.setID( 10 );
console.log( funObj.getID() ); // 10
 

ES6 tan─▒t─▒ld─▒ Ok i┼člevi : Bir ok i┼člevi ifadesinin daha k─▒sa bir s├Âzdizimi vard─▒r, y├Ântem d─▒┼č─▒ i┼člevler i├žin en uygun olanlard─▒r ve yap─▒c─▒ olarak kullan─▒lamazlar.

ArrowFunction : ArrowParameters => ConciseBody .

 const fn = (item) => { return item & 1 ? 'Odd' : 'Even'; };
console.log( fn(2) ); // Even
console.log( fn(3) ); // Odd
 

54


2016-01-25





Kendi cevab─▒m─▒ ekliyorum ├ž├╝nk├╝ di─čer herkes kald─▒rma k─▒sm─▒n─▒ tamamen kaps─▒yordu.

Hangi yolun uzun s├╝redir daha iyi oldu─čunu merak ettim ve ┼čimdi http://jsperf.com sayesinde biliyorum :)


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

─░┼člev bildirimleri daha h─▒zl─▒d─▒r ve web devi i├žin ger├žekten ├Ânemli olan ┼čey bu mu? ;)


39







Ba─člama olu┼čturulduktan sonra bir i┼člev bildirimi ve bir de─či┼čkene atanan bir i┼člev ifadesi ayn─▒ ┼čekilde davran─▒r.

Bununla birlikte , i┼člev nesnesinin ger├žekte de─či┼čkeni ile nas─▒l ve ne zaman ili┼čkili oldu─ču konusunda bir fark vard─▒r . Bu fark, JavaScript'te de─či┼čken kald─▒rma olarak adland─▒r─▒lan mekanizma nedeniyledir .

Temel olarak, t├╝m i┼člev bildirimleri ve de─či┼čken bildirimleri , bildirimin ger├žekle┼čti─či i┼člevin ├╝st├╝ne getirilir (bu nedenle JavaScript'in i┼člev kapsam─▒ oldu─čunu s├Âyleriz ).

  • Bir i┼člev bildirimi kald─▒r─▒ld─▒─č─▒nda, i┼člev g├Âvdesi "takip eder", b├Âylece i┼člev g├Âvdesi de─čerlendirildi─činde, de─či┼čken hemen bir i┼člev nesnesine ba─član─▒r.

  • De─či┼čken bildirimi ├žekildi─či zaman, ba┼člatma yok de─čil izleyin, ancak "geride" oldu─čunu. De─či┼čken, undefined i┼člev g├Âvdesinin ba┼člang─▒c─▒nda ba┼člat─▒l─▒r ve koddaki orijinal konumuna bir de─čer atan─▒r . (Asl─▒nda, ayn─▒ ada sahip bir de─či┼čken bildiriminin ger├žekle┼čti─či her yerde bir de─čer atanacakt─▒r .)

Kald─▒rma s─▒ras─▒ da ├Ânemlidir: i┼člev bildirimleri ayn─▒ ada sahip de─či┼čken bildirimlerden ├Ânceliklidir ve son i┼člev bildirimi ayn─▒ ada sahip ├Ânceki i┼člev bildirimlerinden ├Ânceliklidir.

Baz─▒ ├Ârnekler...

 var foo = 1;
function bar() {
  if (!foo) {
    var foo = 10 }
  return foo; }
bar() // 10
 

De─či┼čken foo ba┼člat─▒ld─▒ fonksiyon, ├╝st ├žekilir undefined , b├Âylece, !foo bir true ├žok, foo atan─▒r 10 . foo D─▒┼č─▒nda bar bireyin kapsam─▒ hi├žbir rol oynar ve bakir.

 function f() {
  return a; 
  function a() {return 1}; 
  var a = 4;
  function a() {return 2}}
f()() // 2

function f() {
  return a;
  var a = 4;
  function a() {return 1};
  function a() {return 2}}
f()() // 2
 

─░┼člev bildirimleri de─či┼čken bildirimlere g├Âre ├Ânceliklidir ve son i┼člev bildirimi "yap─▒┼čt─▒" d─▒r.

 function f() {
  var a = 4;
  function a() {return 1}; 
  function a() {return 2}; 
  return a; }
f() // 4
 

Bu ├Ârnekte a , ikinci i┼člev bildiriminin de─čerlendirilmesinden kaynaklanan i┼člev nesnesiyle ba┼člat─▒l─▒r ve ard─▒ndan atan─▒r 4 .

 var a = 1;
function b() {
  a = 10;
  return;
  function a() {}}
b();
a // 1
 

Burada ilk ├Ânce i┼člev bildirimi y├╝kseltilir, de─či┼čken bildirilir ve ba┼člat─▒l─▒r a . Ard─▒ndan, bu de─či┼čken atan─▒r 10 . Ba┼čka bir deyi┼čle: atama d─▒┼č de─či┼čkene atamad─▒ a .


32







─░lk ├Ârnek bir i┼člev bildirimidir:

 function abc(){}
 

─░kinci ├Ârnek bir fonksiyon ifadesidir:

 var abc = function() {};
 

Temel fark, nas─▒l kald─▒r─▒ld─▒klar─▒ (kald─▒r─▒ld─▒ ve ilan edildi). ─░lk ├Ârnekte, t├╝m i┼člev bildirimi kald─▒r─▒ld─▒. ─░kinci ├Ârnekte sadece var 'abc' kald─▒r─▒l─▒r, de─čeri (i┼člev) tan─▒mlanmaz ve i┼člevin kendisi bildirildi─či konumda kal─▒r.

Basit├že s├Âylemek gerekirse:

 //this will work
abc(param);
function abc(){}

//this would fail
abc(param);
var abc = function() {}
 

Bu konu hakk─▒nda daha fazla ├žal─▒┼čmak i├žin bu ba─člant─▒y─▒ ┼čiddetle tavsiye ediyorum http://javascriptweblog.wordpress.com/2010/07/06/function-declarations-vs-function-expressions/%23comment-43792#comment-43792


31







Kod bak─▒m maliyeti a├ž─▒s─▒ndan, adland─▒r─▒lm─▒┼č i┼člevler daha ├žok tercih edilir:

  • Bildirildikleri yerden ba─č─▒ms─▒z (ancak yine de kapsam taraf─▒ndan s─▒n─▒rl─▒).
  • Ko┼čullu ba┼člatma gibi hatalara kar┼č─▒ daha diren├žli (istenirse yine de ge├žersiz k─▒labilirsiniz).
  • Yerel i┼člevleri kapsam i┼člevinden ayr─▒ olarak tahsis ederek kod daha okunabilir hale gelir. Genellikle, kapsamda i┼člevsellik ilk ├Ânce yerel i┼člev bildirimlerinin ard─▒ndan gelir.
  • Bir hata ay─▒klay─▒c─▒da, "isimsiz / de─čerlendirilmi┼č" bir i┼člev yerine arama y─▒─č─▒n─▒nda i┼člev ad─▒n─▒ a├ž─▒k├ža g├Âreceksiniz.

Adland─▒r─▒lm─▒┼č fonksiyonlar i├žin daha fazla PROS'un takip edildi─činden ┼č├╝pheleniyorum. Ve adland─▒r─▒lm─▒┼č i┼člevlerin bir avantaj─▒ olarak listelenen, isimsiz olanlar i├žin bir dezavantajd─▒r.

Tarihsel olarak, isimsiz i┼člevler, adland─▒r─▒lm─▒┼č i┼člevlere sahip ├╝yeleri listelemek i├žin JavaScript dilinin yetersizli─činden ortaya ├ž─▒km─▒┼čt─▒r:

 {
    member:function() { /* How do I make "this.member" a named function? */
    }
}
 

28







Kodumdaki de─či┼čken yakla┼č─▒m─▒, teorisi yukar─▒da soyut bir ┼čekilde ele al─▒nan ├žok ├Âzel bir sebepten dolay─▒ kullan─▒yorum, ancak bir ├Ârnek, benim gibi baz─▒ insanlara s─▒n─▒rl─▒ JavaScript uzmanl─▒─č─▒ ile yard─▒mc─▒ olabilir.

Ba─č─▒ms─▒z olarak tasarlanan 160 markayla ├žal─▒┼čmam gereken kodum var. Kodun ├žo─ču payla┼č─▒lan dosyalardad─▒r, ancak markaya ├Âzg├╝ ┼čeyler her marka i├žin ayr─▒ bir dosyadad─▒r.

Baz─▒ markalar belirli i┼člevler gerektirir ve baz─▒lar─▒ gerektirmez. Bazen yeni markala┼čmaya ├Âzg├╝ ┼čeyler yapmak i├žin yeni i┼člevler eklemem gerekiyor. Payla┼č─▒lan kodlar─▒ de─či┼čtirmekten mutluyum, ancak t├╝m 160 marka marka dosyas─▒n─▒ de─či┼čtirmek zorunda kalmak istemiyorum.

De─či┼čken s├Âzdizimini kullanarak, de─či┼čkeni (esas olarak bir i┼člev i┼čaret├žisi) payla┼č─▒lan kodda bildirebilir ve ├Ânemsiz bir saplama i┼člevi atayabilir veya null olarak ayarlayabilirim.

Fonksiyonun belirli bir uygulamas─▒na ihtiya├ž duyan bir veya iki marka daha sonra fonksiyonun versiyonunu tan─▒mlayabilir ve isterlerse de─či┼čkeni atayabilir ve geri kalan hi├žbir ┼čey yapmaz. Payla┼č─▒lan kodda ├žal─▒┼čt─▒rmadan ├Ânce bo┼č bir i┼člevi test edebilirim.

Yukar─▒daki ki┼čilerin yorumlar─▒ndan, statik bir fonksiyonu yeniden tan─▒mlaman─▒n m├╝mk├╝n olabilece─čini d├╝┼č├╝n├╝yorum, ancak de─či┼čken ├ž├Âz├╝m├╝n├╝n iyi ve net oldu─čunu d├╝┼č├╝n├╝yorum.


24


2012-11-29





Bilgisayar bilimi terimlerinde ads─▒z fonksiyonlar ve adland─▒r─▒lm─▒┼č fonksiyonlar hakk─▒nda konu┼čuruz. Bence en ├Ânemli fark, isimsiz bir i┼člevin bir isme, dolay─▒s─▒yla isimsiz i┼čleve ba─čl─▒ olmamas─▒d─▒r. JavaScript'te, ├žal─▒┼čma zaman─▒nda dinamik olarak bildirilen birinci s─▒n─▒f bir nesnedir.

─░simsiz fonksiyonlar ve lambda hesab─▒ hakk─▒nda daha fazla bilgi i├žin Wikipedia iyi bir ba┼člang─▒├žt─▒r ( http://en.wikipedia.org/wiki/Anonymous_function ).


23







Greg'in Cevab─▒ yeterince iyi, ama hala Douglas Crockford'un videolar─▒n─▒ izleyerek ├Â─črendi─čim bir ┼čeyi eklemek istiyorum .

─░┼člev ifadesi:

 var foo = function foo() {};
 

─░┼člev bildirimi:

 function foo() {};
 

Function deyimi, de─čeri var olan bir ifade i├žin k─▒sa yoldur function .

Yani

 function foo() {};
 

i├žin geni┼čler

 var foo = function foo() {};
 

Hangisi daha da geni┼čler:

 var foo = undefined;
foo = function foo() {};
 

Ve ikisi de kodun ├╝st k─▒sm─▒na ├žekilmi┼čtir.


Videodan ekran g├Âr├╝nt├╝s├╝


22







@EugeneLazutkin kendisine dahili bir referans olarak kullanmas─▒ i├žin atanm─▒┼č bir i┼člevi adland─▒rd─▒─č─▒ shortcut() bir ├Ârnek verir . John Resig ba┼čka ├Ârnek verir - ba┼čka bir nesneye atanm─▒┼č bir ├Âzyinelemeli fonksiyon kopyalama onun i├žinde ├ľ─črenme Geli┼čmi┼č JavaScript ├Â─čretici. ─░┼člevleri ├Âzelliklere atamak burada kesinlikle soru olmasa da, ├Â─čreticiyi aktif olarak denemenizi ├Âneririz - sa─č ├╝st k├Â┼čedeki d├╝─čmeyi t─▒klatarak kodu ├žal─▒┼čt─▒r─▒n ve be─čeninize d├╝zenlemek i├žin kodu ├žift t─▒klay─▒n.

├ľ─čreticiden ├Ârnekler: ├Âzyinelemeli aramalar yell() :

Orijinal ninja nesnesi kald─▒r─▒ld─▒─č─▒nda testler ba┼čar─▒s─▒z olur. (sayfa 13)

 var ninja = { 
  yell: function(n){ 
    return n > 0 ? ninja.yell(n-1) + "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "A single object isn't too bad, either." ); 

var samurai = { yell: ninja.yell }; 
var ninja = null; 

try { 
  samurai.yell(4); 
} catch(e){ 
  assert( false, "Uh, this isn't good! Where'd ninja.yell go?" ); 
}
 

Tekrarlayan olarak adland─▒r─▒lacak i┼člevi isimlendirirseniz, testler ba┼čar─▒l─▒ olacakt─▒r. (sayfa 14)

 var ninja = { 
  yell: function yell(n){ 
    return n > 0 ? yell(n-1) + "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "Works as we would expect it to!" ); 

var samurai = { yell: ninja.yell }; 
var ninja = {}; 
assert( samurai.yell(4) == "hiyaaaa", "The method correctly calls itself." );
 

18







Di─čer cevaplarda belirtilmeyen bir ba┼čka fark ise, isimsiz fonksiyonu kullan─▒yorsan─▒z

 var functionOne = function() {
    // Some code
};
 

ve bunu, oldu─ču gibi bir kurucu olarak kullan─▒n.

 var one = new functionOne();
 

o one.constructor.name zaman tan─▒mlanmayacak. Function.name standart de─čildir ancak Firefox, Chrome, di─čer Webkit t├╝revi taray─▒c─▒lar ve IE 9+ taraf─▒ndan desteklenir.

─░le

 function functionTwo() {
    // Some code
}
two = new functionTwo();
 

Yap─▒c─▒n─▒n ismini bir dize olarak almak m├╝mk├╝nd├╝r two.constructor.name .


16







Nesneleri olu┼čturmak i├žin bu i┼člevleri kullan─▒rsan─▒z ┼čunlar─▒ al─▒rs─▒n─▒z:

 var objectOne = new functionOne();
console.log(objectOne.__proto__); // prints "Object {}" because constructor is an anonymous function

var objectTwo = new functionTwo();
console.log(objectTwo.__proto__); // prints "functionTwo {}" because constructor is a named function
 

14







─░lki (i┼člev doSomething (x)), bir nesne g├Âsteriminin bir par├žas─▒ olmal─▒d─▒r.

─░kincisi ( var doSomething = function(x){ alert(x);} ), basit├že ads─▒z bir i┼člev olu┼čturmak ve onu bir de─či┼čkene atamak doSomething ,. B├Âylece DoSomething () i┼člevi ├ža─č─▒r─▒r.

Bir i┼člev bildirimi ve i┼člev ifadesinin ne oldu─čunu bilmek isteyebilirsiniz .

Bir i┼člev bildirimi, de─či┼čken atamas─▒ gerektirmeden adland─▒r─▒lm─▒┼č bir i┼člev de─či┼čkenini tan─▒mlar. ─░┼člev bildirimleri, ba─č─▒ms─▒z yap─▒lar olarak ger├žekle┼čir ve i┼člev d─▒┼č─▒ bloklar─▒n i├žine yerle┼čtirilemez.

 function foo() {
    return 3;
}
 

ECMA 5 (13.0), s├Âzdizimini
fonksiyon tan─▒mlay─▒c─▒s─▒ (FormalParameterList opt ) {FunctionBody} olarak tan─▒mlar.

Yukar─▒daki durumda, i┼člev ad─▒ kapsam─▒ i├žinde ve ana ├Â─česinin kapsam─▒ i├žinde g├Âr├╝n├╝r (aksi takdirde eri┼čilemez).

Ve bir fonksiyon ifadesinde

Bir i┼člev ifadesi, bir i┼člevi daha b├╝y├╝k ifade s├Âzdiziminin bir par├žas─▒ olarak tan─▒mlar (tipik olarak de─či┼čken atamas─▒). ─░┼člev ifadeleriyle tan─▒mlanan i┼člevler adland─▒r─▒lm─▒┼č veya ads─▒z olabilir. ─░┼člev ifadeleri ÔÇťfunctionÔÇŁ ile ba┼člamamal─▒d─▒r.

 // Anonymous function expression
var a = function() {
    return 3;
}

// Named function expression
var a = function foo() {
    return 3;
}

// Self-invoking function expression
(function foo() {
    alert("hello!");
})();
 

ECMA 5 (13.0), s├Âzdizimini
fonksiyon tan─▒mlay─▒c─▒s─▒ opt (FormalParameterList opt ) {FunctionBody} olarak tan─▒mlar.


14







A┼ča─č─▒daki farklar─▒ s─▒ral─▒yorum:

  1. Bir fonksiyon bildirimi kodun herhangi bir yerine yerle┼čtirilebilir. Tan─▒m, kodda g├Âr├╝nmeden ├Ânce ├ža─čr─▒lsa bile, i┼člev bildirimi belle─če veya bir ┼čekilde kald─▒r─▒lm─▒┼č ┼čekilde, sayfadaki di─čer herhangi bir kod y├╝r├╝t├╝lmeden ├Ânce ├žal─▒┼čt─▒r─▒l─▒r.

    A┼ča─č─▒daki i┼čleve bir g├Âz at─▒n:

     function outerFunction() {
        function foo() {
           return 1;
        }
        return foo();
        function foo() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 2
     

    Bunun nedeni, y├╝r├╝tme s─▒ras─▒nda ┼č├Âyle g├Âr├╝nmesidir: -

     function foo() {  // The first function declaration is moved to top
        return 1;
    }
    function foo() {  // The second function declaration is moved to top
        return 2;
    }
    function outerFunction() {
        return foo();
    }
    alert(outerFunction()); //So executing from top to bottom,
                            //the last foo() returns 2 which gets displayed
     

    ├ça─čr─▒lmadan ├Ânce tan─▒mlanmad─▒ysa, bir i┼člev ifadesi bir hataya neden olur. Ayr─▒ca, burada i┼člev tan─▒m─▒n─▒n kendisi, i┼člev bildirimlerindeki gibi belle─če ta┼č─▒nmaz veya belle─če y├╝klenmez. Ancak, i┼člevi atad─▒─č─▒m─▒z de─či┼čken y├╝kseltilir ve tan─▒ms─▒z , ona atan─▒r.

    ─░┼člev ifadelerini kullanarak ayn─▒ i┼člev:

     function outerFunction() {
        var foo = function() {
           return 1;
        }
        return foo();
        var foo = function() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 1
     

    Bunun nedeni y├╝r├╝tme s─▒ras─▒nda ┼č├Âyle g├Âz├╝kmesidir:

     function outerFunction() {
       var foo = undefined;
       var foo = undefined;
    
       foo = function() {
          return 1;
       };
       return foo ();
       foo = function() {   // This function expression is not reachable
          return 2;
       };
    }
    alert(outerFunction()); // Displays 1
     
  2. Sanki olmayan fonksiyon bloklar─▒nda i┼člev a├ž─▒klamalar─▒n─▒ yazmak i├žin g├╝venli de─čil ise onlar eri┼čilebilir olmayacakt─▒r ├ž├╝nk├╝.

     if (test) {
        function x() { doSomething(); }
    }
     
  3. A┼ča─č─▒daki gibi adland─▒r─▒lm─▒┼č i┼člev ifadesi, s├╝r├╝m 9'dan ├Ânceki Internet Explorer taray─▒c─▒lar─▒nda ├žal─▒┼čmayabilir.

     var today = function today() {return new Date()}
     

14







????? ??? ???? ?????????? ??????????? ??? ??? ??? ????????? ???????????? ?? ????????? ?? ?????? ?????.

  1. ─░┼člevin kullan─▒labilirli─či (kapsam─▒)

A┼ča─č─▒dakiler ├žal─▒┼č─▒r, ├ž├╝nk├╝ function add() en yak─▒n blo─čun kapsam─▒ vard─▒r:

 try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

function add(a, b){
  return a + b;
} 

De─či┼čkene bir i┼člev de─čeri atanmadan ├Ânce de─či┼čken ├ža─čr─▒ld─▒─č─▒ i├žin a┼ča─č─▒dakiler ├žal─▒┼čmaz add .

 try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

var add=function(a, b){
  return a + b;
} 

Yukar─▒daki kod i┼člevselli─či a├ž─▒s─▒ndan a┼ča─č─▒daki kodla ayn─▒d─▒r. A├ž─▒k├ža ataman─▒n add = undefined gereksiz oldu─čuna dikkat edin, ├ž├╝nk├╝ sadece yapmak var add; ayn─▒d─▒r var add=undefined .

 var add = undefined;

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

add = function(a, b){
  return a + b;
} 

├ç├╝nk├╝ ┼ču ├žal─▒┼čm─▒yor var add= superseeds function add() .

 try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

var add=function add(a, b){
  return a + b;
} 

  1. (i┼člev) .name

Bir i┼člevin ad─▒ function thefuncname(){} olan thefuncname bu ┼čekilde beyan edildi─činde.

 function foobar(a, b){}

console.log(foobar.name); 

 var a = function foobar(){};

console.log(a.name); 

Aksi halde, bir i┼člev olarak bildirilirse function(){} , i┼člev .name i┼člevi depolamak i├žin kullan─▒lan ilk de─či┼čkendir.

 var a = function(){};
var b = (function(){ return function(){} });

console.log(a.name);
console.log(b.name); 

─░┼čleve ayarlanm─▒┼č de─či┼čken yoksa, i┼člev ad─▒ bo┼č dizedir ( "" ).

 console.log((function(){}).name === ""); 

Son olarak, i┼člev ba┼člang─▒├žta ismi atanan de─či┼čken atan─▒rken, i┼čleve atanan de─či┼čkenler ismi de─či┼čtirmez.

 var a = function(){};
var b = a;
var c = b;

console.log(a.name);
console.log(b.name);
console.log(c.name); 

  1. performans

GoogleÔÇÖ─▒n V8 ve FirefoxÔÇÖun SpidermonkeyÔÇÖinde birka├ž mikrosaniye JIST derleme fark─▒ olabilir, ancak sonu├žta ayn─▒. Bunu kan─▒tlamak i├žin, iki bo┼č kod snippetinin h─▒z─▒n─▒ kar┼č─▒la┼čt─▒rarak JSPerf'in mikrob├Âceklerdeki verimlili─čini inceleyelim. JSPerf Testler burada bulunur . Ve, jsben.ch testleri burada bulundu . G├Ârd├╝─č├╝n├╝z gibi, hi├ž olmamas─▒ gerekti─činde fark edilir bir fark var. E─čer ger├žekten benim gibi bir performans d├╝┼čk├╝n├╝yseniz, kapsamdaki de─či┼čkenleri ve i┼člevleri azaltmak ve ├Âzellikle polimorfizmi ortadan kald─▒rmak (├Âzellikle iki farkl─▒ t├╝r├╝ depolamak i├žin ayn─▒ de─či┼čkeni kullanmak gibi) i├žin daha de─čerli olabilir.

  1. De─či┼čken De─či┼čkenlik

Bir var de─či┼čkeni bildirmek i├žin anahtar kelimeyi kulland─▒─č─▒n─▒zda, bunun gibi de─či┼čkene farkl─▒ bir de─čer atayabilirsiniz.

 (function(){
    "use strict";
    var foobar = function(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: " + error.message);
    }
    console.log(foobar, window.foobar);
})(); 

Bununla birlikte, const deyimini kulland─▒─č─▒m─▒zda, de─či┼čken referans─▒ de─či┼čmez hale gelir. Bu, de─či┼čkene yeni bir de─čer atayamayaca─č─▒m─▒z anlam─▒na gelir. Bununla birlikte, bunun de─či┼čkenin i├žeri─čini de─či┼čmez hale getirmedi─čini unutmay─▒n: e─čer const arr = [] ├Âyleyse, yine de yapabilirsiniz arr[10] = "example" . Sadece b├Âyle bir ┼čey yapmak arr = "new value" veya arr = [] a┼ča─č─▒da g├Âr├╝ld├╝─č├╝ gibi bir hata atmak olacakt─▒r.

 (function(){
    "use strict";
    const foobar = function(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: " + error.message);
    }
    console.log(foobar, window.foobar);
})(); 

─░lgin├žtir ki, function funcName(){} de─či┼čkeni olarak bildirirsek, de─či┼čkenin de─či┼čmezli─či ile bildirmek ayn─▒d─▒r var .

 (function(){
    "use strict";
    function foobar(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: " + error.message);
    }
    console.log(foobar, window.foobar);
})(); 

???? ?? ??? "??????? ?????"

"En yak─▒n blok", en yak─▒n "i┼člev" dir (asenkron i┼člevler, jenerat├Âr i┼člevleri ve asenkron jenerat├Âr i┼člevleri dahil). Bununla birlikte, ilgin├ž bir ┼čekilde, kapanma d─▒┼č─▒ bir blokta bahsedilen kapanma d─▒┼č─▒ndaki ├Â─čelere bir s├╝re function functionName() {} gibi davran─▒r var functionName = function() {} . G├Âzlemek.

  • Normal var add=function(){}

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}');
  }
} catch(e) {
  console.log("Is a block");
}
var add=function(a, b){return a + b} 

  • Normal function add(){}

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
function add(a, b){
  return a + b;
} 

  • fonksiyon

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(function () {
    function add(a, b){
      return a + b;
    }
})(); 

  • A├ž─▒klama (├Ârne─čin if , else , for , while , try / catch / finally , switch , do / while , with )

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
{
    function add(a, b){
      return a + b;
    }
} 

  • Ok i┼člevi var add=function()

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    var add=function(a, b){
      return a + b;
    }
})(); 

  • Ok i┼člevi function add()

 try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    function add(a, b){
      return a + b;
    }
})(); 


13







"Y─▒─č─▒n izlerinde g├Âsterilen adland─▒r─▒lm─▒┼č i┼člevler" arg├╝man─▒ ─▒┼č─▒─č─▒nda, modern JavaScript motorlar─▒ asl─▒nda isimsiz i┼člevleri g├Âsterme yetene─čine sahiptir.

Bu yaz─▒ itibariyle, V8, SpiderMonkey, ├çakra ve Nitro her zaman isimleri ile isimlendirilmi┼č i┼člevleri ifade eder. Neredeyse her zaman bir kimli─či varsa, tan─▒mlay─▒c─▒s─▒ taraf─▒ndan ads─▒z bir i┼čleve i┼čaret eder.

SpiderMonkey, ba┼čka bir i┼člevden d├Ând├╝r├╝len ads─▒z bir i┼člevin ad─▒n─▒ bulabilir. Gerisi yapamaz.

Ger├žekten, ger├žekten yinelemecinizin ve ba┼čar─▒ geri ├ža─čr─▒lar─▒n─▒z─▒n izlemede g├Âr├╝nmesini istiyorsan─▒z, bunlar─▒ da adland─▒rabilirsiniz ...

 [].forEach(function iterator() {});
 

Ancak ├žo─ču zaman ├╝zerinde bask─▒ yapmaya de─čmez.

Ko┼čum ( Keman )

 'use strict';

var a = function () {
    throw new Error();
},
    b = function b() {
        throw new Error();
    },
    c = function d() {
        throw new Error();
    },
    e = {
        f: a,
        g: b,
        h: c,
        i: function () {
            throw new Error();
        },
        j: function j() {
            throw new Error();
        },
        k: function l() {
            throw new Error();
        }
    },
    m = (function () {
        return function () {
            throw new Error();
        };
    }()),
    n = (function () {
        return function n() {
            throw new Error();
        };
    }()),
    o = (function () {
        return function p() {
            throw new Error();
        };
    }());

console.log([a, b, c].concat(Object.keys(e).reduce(function (values, key) {
    return values.concat(e[key]);
}, [])).concat([m, n, o]).reduce(function (logs, func) {

    try {
        func();
    } catch (error) {
        return logs.concat('func.name: ' + func.name + '\n' +
                           'Trace:\n' +
                           error.stack);
        // Need to manually log the error object in Nitro.
    }

}, []).join('\n\n'));
 

V8

 func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at e.i (http://localhost:8000/test.js:17:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: j
Trace:
Error
    at j (http://localhost:8000/test.js:20:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: l
Trace:
Error
    at l (http://localhost:8000/test.js:23:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at http://localhost:8000/test.js:28:19
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: n
Trace:
Error
    at n (http://localhost:8000/test.js:33:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: p
Trace:
Error
    at p (http://localhost:8000/test.js:38:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27 test.js:42
 

├ľr├╝mcek maymunu

 func.name: 
Trace:
[email protected]http://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
[email protected]://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
[email protected]://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
[email protected]://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
[email protected]://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
[email protected]://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
[email protected]://localhost:8000/test.js:17:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: j
Trace:
[email protected]://localhost:8000/test.js:20:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: l
Trace:
[email protected]://localhost:8000/test.js:23:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
m</<@http://localhost:8000/test.js:28:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: n
Trace:
[email protected]://localhost:8000/test.js:33:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: p
Trace:
[email protected]://localhost:8000/test.js:38:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1
 

├žakra

 func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at e.i (http://localhost:8000/test.js:17:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at j (http://localhost:8000/test.js:20:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at l (http://localhost:8000/test.js:23:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at Anonymous function (http://localhost:8000/test.js:28:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at n (http://localhost:8000/test.js:33:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at p (http://localhost:8000/test.js:38:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)
 

nitro

 func.name: 
Trace:
[email protected]://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: b
Trace:
[email protected]://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: d
Trace:
[email protected]://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: 
Trace:
[email protected]://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: b
Trace:
[email protected]://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: d
Trace:
[email protected]://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: 
Trace:
[email protected]://localhost:8000/test.js:17:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: j
Trace:
[email protected]://localhost:8000/test.js:20:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: l
Trace:
[email protected]://localhost:8000/test.js:23:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: 
Trace:
http://localhost:8000/test.js:28:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: n
Trace:
[email protected]://localhost:8000/test.js:33:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33

func.name: p
Trace:
[email protected]://localhost:8000/test.js:38:30
http://localhost:8000/test.js:47:13
[email protected][native code]
global [email protected]://localhost:8000/test.js:44:33
 

11







JavaScript'te i┼člev olu┼čturman─▒n iki yolu vard─▒r:

  1. ─░┼člev bildirimi:

     function fn(){
      console.log("Hello");
    }
    fn();
     

    Bu ├žok basit, a├ž─▒klay─▒c─▒, bir├žok dilde ve C ailesi dillerinde standart olarak kullan─▒l─▒yor. Bir fonksiyon tan─▒mlad─▒k ve onu ├ža─č─▒rarak ├žal─▒┼čt─▒rd─▒k.

    Bilmeniz gereken, i┼člevlerin asl─▒nda JavaScript'teki nesneler oldu─ču; dahili olarak yukar─▒daki i┼člev i├žin bir nesne yaratt─▒k ve ona fn ad─▒nda bir ad verdik veya nesneye referans fn'de sakland─▒. ─░┼člevler, JavaScript'teki nesnelerdir; bir fonksiyon ├Ârne─či asl─▒nda bir nesne ├Ârne─čidir.

  2. ─░┼člev ifadesi:

     var fn=function(){
      console.log("Hello");
    }
    fn();
     

    JavaScript birinci s─▒n─▒f i┼člevlere sahiptir, yani bir i┼člev olu┼čturun ve onu bir dize veya say─▒ olu┼čturdu─čunuz gibi bir de─či┼čkene atay─▒n ve onu bir de─či┼čkene atay─▒n. Burada, fn de─či┼čkeni bir i┼čleve atan─▒r. Bu kavram─▒n nedeni fonksiyonlar─▒n JavaScript'teki nesneler olmas─▒d─▒r; fn, yukar─▒daki i┼člevin nesne ├Ârne─čine i┼čaret ediyor. Bir i┼člevi ba┼člatt─▒k ve onu bir de─či┼čkene atad─▒k. ─░┼člevi ├žal─▒┼čt─▒rm─▒yor ve sonucu atam─▒yor.

Referans: JavaScript i┼člev bildirimi s├Âzdizimi: var fn = function () {} vs function fn () {}


10







Her ikisi de bir i┼člevi tan─▒mlaman─▒n farkl─▒ yollar─▒d─▒r. Fark, taray─▒c─▒n─▒n bunlar─▒ y├╝r├╝tme ba─člam─▒na nas─▒l yorumlad─▒─č─▒ ve y├╝kledi─čidir.

─░lk durum, yaln─▒zca terc├╝man bu kod sat─▒r─▒na ula┼čt─▒─č─▒nda y├╝klenen i┼člev ifadeleridir. B├Âylece, a┼ča─č─▒daki gibi yaparsan─▒z, functionOne'─▒n bir i┼člev olmad─▒─č─▒ konusunda bir hata al─▒rs─▒n─▒z .

 functionOne();
var functionOne = function() {
    // Some code
};
 

Bunun nedeni, ilk sat─▒rda functionOne ├Â─česine hi├žbir de─čer atanmamas─▒ ve bu nedenle tan─▒ms─▒z olmas─▒d─▒r. Bunu i┼člev olarak adland─▒rmaya ├žal─▒┼č─▒yoruz ve bu nedenle hata al─▒yoruz.

─░kinci sat─▒rda functionOne'a ads─▒z bir i┼člevin referans─▒n─▒ veriyoruz.

─░kinci durum, herhangi bir kod y├╝r├╝t├╝lmeden ├Ânce y├╝klenen i┼člev bildirimleridir. Dolay─▒s─▒yla, a┼ča─č─▒dakileri be─čendiyseniz, bildirimin kod y├╝r├╝tmeden ├Ânce y├╝kledi─či gibi herhangi bir hatayla kar┼č─▒la┼čmazs─▒n─▒z.

 functionOne();
function functionOne() {
   // Some code
}
 

9







Performans hakk─▒nda:

Yeni versiyonlar, V8 ba┼čl─▒k alt─▒ optimizasyonlar─▒n bir├žo─čunu sundu ve yapt─▒ SpiderMonkey .

Art─▒k ifade ve bildirim aras─▒nda neredeyse hi├žbir fark yoktur.
─░┼člev ifadesi ┼čimdi daha h─▒zl─▒ g├Âr├╝n├╝yor .

Chrome 62.0.3202
Chrome testi

FireFox 55
Firefox testi

Krom Kanarya 63.0.3225
Chrome Kanarya testi


Anonymous i┼člev ifadelerinin i┼člev ifadesine kar┼č─▒ daha iyi performans g├Âsterdi─či g├Âr├╝lmektedir Named .


Firefox Krom Kanarya Krom
Firefox adl─▒_anonymous


Adl─▒ Chrome kanarya_anonymous


Chrome adl─▒_anonymous


9







Baz─▒ k├╝├ž├╝k farkl─▒l─▒klara olduk├ža benziyorlar, birincisi ads─▒z bir i┼čleve atanan bir de─či┼čken (─░┼člev Beyan─▒) ve ikincisi de JavaScript'te bir i┼člev olu┼čturman─▒n normal yoludur (Anonim i┼člev Bildirimi), kullan─▒m─▒, eksileri ve art─▒lar─▒ var :

1. ─░┼člev ─░fadesi

 var functionOne = function() {
    // Some code
};
 

Bir ─░┼člev ─░fadesi, bir i┼člevi daha b├╝y├╝k bir ifade s├Âzdiziminin (tipik olarak de─či┼čken atamas─▒) bir par├žas─▒ olarak tan─▒mlar. ─░┼člevler ─░fadeleri ile tan─▒mlanan i┼člevler adland─▒r─▒lm─▒┼č veya ads─▒z olabilir. ─░┼člev ─░fadeleri ÔÇťi┼člevÔÇŁ ile ba┼člamamal─▒d─▒r (bu nedenle a┼ča─č─▒daki kendi kendine ├ža─čr─▒ ├Ârne─či etraf─▒ndaki parantezler).

Bir i┼čleve de─či┼čken atama, kald─▒rma anlam─▒na gelmez, ├ž├╝nk├╝ JavaScript'teki i┼člevlerin kald─▒rabildi─čini bildi─čimizden, bunlar─▒n bildirilmeden ├Ânce ├ža─čr─▒labilece─či anlam─▒na gelir, de─či┼čkenlerin kendilerine eri┼čmeden ├Ânce bildirilmeleri gerekir, bu durumda bu durumda yapamay─▒z demektir. i┼čleve bildirildi─či yerden ├Ânce eri┼čebilir, ayr─▒ca i┼člevlerinizi yazman─▒n bir yolu olabilir, ba┼čka bir i┼člevi d├Ând├╝ren i┼člevler i├žin, bu t├╝r bir bildirim anlaml─▒ olabilir, ECMA6'da ve ├╝st├╝nde bunu bir ok i┼člevine atayabilirsiniz. anonim i┼člevleri ├ža─č─▒rmak i├žin kullan─▒labilir, ayr─▒ca bu ┼čekilde bildirmek, JavaScript'te Olu┼čturucu i┼člevler olu┼čturman─▒n daha iyi bir yoludur.

2. ─░┼člev Beyan─▒

 function functionTwo() {
    // Some code
}
 

Bir ─░┼člev Bildirimi, de─či┼čken atamas─▒ gerektirmeden adland─▒r─▒lm─▒┼č bir i┼člev de─či┼čkenini tan─▒mlar. ─░┼člev Bildirimleri, ba─č─▒ms─▒z yap─▒lar olarak ger├žekle┼čir ve i┼člev d─▒┼č─▒ bloklar─▒n i├žine yerle┼čtirilemez. Bunlar─▒ De─či┼čken Beyanlar─▒'n─▒n karde┼čleri olarak d├╝┼č├╝nmek faydal─▒d─▒r. De─či┼čken Beyannamelerin ÔÇťvarÔÇŁ ile ba┼člamas─▒ gerekti─či gibi, Fonksiyon Beyanlar─▒ da ÔÇťfonksiyonÔÇŁ ile ba┼člamal─▒d─▒r.

Bu, JavaScript'te bir i┼člevi ├ža─č─▒rman─▒n normal yoludur, bu i┼člev, JavaScript'te t├╝m i┼člevlerin Kald─▒r─▒lm─▒┼č oldu─čunu bildirmeden ├Ânce ├ža─čr─▒labilir, ancak 'kat─▒ kullan─▒yorsan─▒z' bu beklendi─či gibi kald─▒r─▒lmaz, bu iyi bir yoldur Sat─▒r i├ži b├╝y├╝k olmayan ve yap─▒c─▒ olan t├╝m normal fonksiyonlar─▒ ├ža─č─▒rmak.

Ayr─▒ca, kald─▒rmada JavaScriptÔÇÖin nas─▒l ├žal─▒┼čt─▒─č─▒ hakk─▒nda daha fazla bilgiye ihtiyac─▒n─▒z olursa, a┼ča─č─▒daki ba─člant─▒y─▒ ziyaret edin:

https://developer.mozilla.org/en-US/docs/Glossary/Hoisting


8







Bu, i┼člevleri bildirmenin yaln─▒zca iki olas─▒ yoludur ve ikinci ┼čekilde, i┼člevi bildirimden ├Ânce kullanabilirsiniz.


6


2015-06-24





new Function() i┼člevin g├Âvdesini bir dizgede ge├žirmek i├žin kullan─▒labilir. Bu nedenle dinamik fonksiyonlar olu┼čturmak i├žin kullan─▒labilir. Ayr─▒ca komut dosyas─▒n─▒ ├žal─▒┼čt─▒rmadan komut dosyas─▒n─▒ ge├žirme.

 var func = new Function("x", "y", "return x*y;");
function secondFunction(){
   var result;
   result = func(10,20);
   console.log ( result );
}

secondFunction()
 

5



─░lgili yay─▒nlar


SQL Server'da ─░┼čleve Kar┼č─▒ Sakl─▒ Prosed├╝r

─░┼člevsel Programlamaya Kar┼č─▒ OOP - Prosed├╝r [kapal─▒]

├çoklu ─░fade Tablosu De─čerli ─░┼člev - Sat─▒r ─░├ži Tablo De─čerli ─░┼člev

Yap─▒c─▒ i┼člevi - Fabrika i┼člevleri

Operat├Âr a┼č─▒r─▒ y├╝klenmesi: ├╝ye i┼člevi vs ├╝ye olmayan i┼člevi?

$ (document) .on ('click', '#id', function () {}) vs $ ('# id'). on ('click', function () {}) [kapal─▒]

$ (document) .ready (function () VS $ (function () {[duplicate]

Mod├╝l fonksiyonu vs staticmethod vs classmethod vs dekorat├Âr yok: Hangi deyim daha pitonik?

Scala: Seq'i var-args fonksiyonlar─▒na aktar

Bir statik i┼člev yerine arkada┼č i┼člevini nerede kullan─▒rs─▒n─▒z?

Etiketle ilgili di─čer sorular [javascript]


Xcode - 'NSUnknownKeyException' ifadesini nas─▒l d├╝zeltebilirim? Sebep:ÔÇŽ Bu s─▒n─▒f, X anahtar─▒n─▒n kod de─čeriyle uyumlu anahtar de─čeri de─čil midir?

Bir .vimrc dosyas─▒ndaki <lider> nedir?

T├╝r ad─▒ndan sonraki parantezler yeniyle fark yarat─▒r m─▒?

Windows'ta npm'yi nas─▒l g├╝ncelleyebilirim?

Go'daki enumslar─▒ temsil etmenin aptalca bir yolu nedir?

Zaman uyumsuz bir geri ├ža─č─▒rma i┼člevinden de─čer nas─▒l d├Ând├╝r├╝l├╝r? [├žift]

L├╝tfen bu birle┼čtirmenin neden gerekli oldu─čunu a├ž─▒klamak i├žin bir onay mesaj─▒ girin, ├Âzellikle de g├╝ncelle┼čtirilmi┼č bir yukar─▒ ak─▒┼č bir konu dal─▒nda birle┼čtirilirse

CSV olarak Yan─▒t ─░├žeri─či t├╝r├╝

Kaynak denetimi i├žin Visual Studio 2015 .vs klas├Âr├╝n├╝ eklemeli miyim?

2 adede kadar ondal─▒k basamak veya basit tam say─▒ g├Âstermek i├žin Dize Format─▒ kullanma