JavaScript sözdizimi - JavaScript syntax

Sözdizimi arasında JavaScript , doğru bir şekilde yapılandırılmış bir JavaScript programı, önceden tanımlanmış kurallar kümesidir.

Aşağıdaki örnekler, standart metin çıktısı için çoğu tarayıcıda bulunan konsol nesnesinin günlük işlevini kullanır .

JavaScript standart kitaplığında resmi bir standart metin çıktı işlevi yoktur ( hariç document.write). JavaScript'in esas olarak modern web tarayıcılarında istemci tarafı komut dosyası oluşturma için kullanıldığı ve hemen hemen tüm Web tarayıcılarının uyarı işlevi sağladığı göz önüne alındığında , uyarı da kullanılabilir, ancak yaygın olarak kullanılmaz.

kökenler

Brendan Eich , JavaScript 1.1 spesifikasyonunun ilk paragrafında sözdiziminin kökenini şu şekilde özetledi:

JavaScript onun sözdizimi en ödünç Java , aynı zamanda devraldığı Awk ve Perl bazı dolaylı etkisi ile, Self onun nesne prototip sisteminde.

Temel bilgiler

Büyük küçük harf duyarlılığı

JavaScript büyük/ küçük harfe duyarlıdır . Bir adını başlatmak için ortak yapıcısı bir ile harfle harfi ve küçük harf ile bir fonksiyonu veya değişkenin adı.

Örnek:

var a=5;
console.log(a); // 5
console.log(A); // throws a ReferenceError: A is not defined

Boşluk ve noktalı virgül

C'den farklı olarak , JavaScript kaynağındaki boşluk, semantiği doğrudan etkileyebilir . Noktalı virgüller JavaScript'te ifadeleri sonlandırır. Çünkü otomatik noktalı virgül yerleştirilmesi noktalı virgül yeni satır için hemen önce yerleştirilir sanki (ASI), bir yeni satır ayrıştırıldığında de oluşan bazı ifadeler, tamamen kabul edilecektir. Bazı yetkililer, otomatik noktalı virgül eklemenin istenmeyen etkilerini azaltabileceğinden, deyimi sonlandıran noktalı virgüllerin açıkça belirtilmesini tavsiye eder.

İki sorun vardır: beş belirteç bir ifadeye başlayabilir veya tam bir ifadenin uzantısı olabilir; ve belirli konumlarda satır sonlarına izin verilmeyen ve potansiyel olarak yanlış ayrıştırmayla sonuçlanabilecek beş sınırlı üretim.

Beş sorunlu belirteç açık parantez " ( ", parantez açın " [ ", eğik çizgi " / ", artı " + " ve eksi " - ". Bunlardan, açık parantez hemen çağrılan işlev ifadesi modelinde yaygındır , ve açık parantez bazen oluşur, diğerleri ise oldukça nadirdir.Spesifikasyonda verilen örnek:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

önceki ifadenin noktalı virgülle sonlandırılması önerisiyle.

Bazı yerine kullanımını önermektedir gelen 'ile başlayan hatlarında noktalı virgül ( ' veya ' [ hattı yanlışlıkla bir önceki ile birleştirilmiş değildir, bu yüzden,'. Bu olarak bilinen bir savunma noktalı ve özellikle tavsiye edilmektedir, kod aksi olabilir, çünkü yeniden düzenlendiğinde belirsizdir. Örneğin:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Başlangıç ​​noktalı virgülleri bazen JavaScript kitaplıklarının başında, sonunda noktalı virgül atlayan başka bir kitaplığa eklenmeleri durumunda kullanılır, çünkü bu ilk ifadenin belirsizliğine neden olabilir.

Beş kısıtlı üretim, dönüş , atma , ara , devam ve artış/azalma sonrasıdır. Her durumda, noktalı virgül eklemek sorunu çözmez, ancak ayrıştırılan sözdizimini netleştirerek hatanın daha kolay algılanmasını sağlar. dönüş ve atma isteğe bağlı bir değer alırken, ara ve devam et isteğe bağlı bir etiket alır. Her durumda tavsiye, değeri veya etiketi ifadeyle aynı satırda tutmaktır. Bu genellikle, yeni bir satırdan başlayarak yanlışlıkla yerleştirilebilecek büyük bir nesne değişmezinin döndürülebileceği return ifadesinde ortaya çıkar. Arttırma/azaltma sonrası için, ön artırma/azaltma ile ilgili potansiyel belirsizlik vardır ve yine bunları aynı satırda tutmanız önerilir.

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Yorumlar

Yorum sözdizimi C++ , Swift ve diğer birçok dilde aynıdır .

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Değişkenler

Standart JavaScript'teki değişkenlerin eklenmiş bir türü yoktur , bu nedenle herhangi bir değer (her değerin bir türü vardır) herhangi bir değişkende saklanabilir. Dilin 6. versiyonu olan ES6 ile başlayarak , değişkenler varfonksiyon kapsamındaki değişkenler için letveya blok düzeyindeki değişkenler için bildirilebilir. ES6'dan önce değişkenler yalnızca bir deyimle bildirilebilirdi . İle bildirilen değişkenlere atanan değerler değiştirilemez, ancak özellikleri değişebilir. Bir değişkenin tanımlayıcısı bir harf, alt çizgi ( _ ) veya dolar işareti ( $ ) ile başlamalıdır , sonraki karakterler de rakamlar olabilir ( 0-9 ). JavaScript büyük/küçük harf duyarlıdır, bu nedenle "A" ile "Z" arasındaki büyük harfler, "a" ile "z" arasındaki küçük harf karakterlerinden farklıdır. constvarconst

JavaScript 1.5 ile başlayarak, ISO 8859-1 veya Unicode harfler (veya \uXXXX Unicode kaçış dizileri) tanımlayıcılarda kullanılabilir. Bazı JavaScript uygulamalarında, @ işareti bir tanımlayıcıda kullanılabilir, ancak bu, spesifikasyonlara aykırıdır ve daha yeni uygulamalarda desteklenmez.

Kapsam belirleme ve kaldırma

Değişkenler ile beyan varedilir lexically kapsamlı bir de işlev düzeyine sahip olanlar ise, letya constbir var blok düzeyinde kapsamını. Bildirimler, herhangi bir kod yürütülmeden önce işlenir. Bu olarak adlandırılır kaldırma , vefonksiyonun veya bloğun tepesindeileriye doğru bildirilendeğişkenlere eşdeğerdir.

İle var, letve consttablolar sadece beyan çekiliyor; atamalar kaldırılmaz. Bu nedenle , fonksiyonun ortasındaki bir ifade, fonksiyonun tepesindeki bir bildirim ifadesine ve fonksiyonun ortasındaki o noktada bir atama ifadesine eşdeğerdir . Bu, değerler bildirilmeden önce erişilemeyeceği anlamına gelir; ileri referans mümkün değildir. İle bir değişkenin değeri olan bu başlatıldı kadar. İle bildirilen değişkenlere veya başlatılıncaya kadar erişilemez, bu nedenle değişkene başvurmak bir hataya neden olur. var x = 1var xx = 1varundefinedletconst

Bir değişken bildiren ve ona bir işlev atayan işlev bildirimleri, değişken ifadelere benzer, ancak bildirimi kaldırmanın yanı sıra atamayı da - sanki tüm ifade içeren işlevin en üstünde görünüyormuş gibi - ve böylece ileri referans da mümkündür: bir çevreleyen fonksiyon içindeki bir fonksiyon ifadesinin konumu önemsizdir. Bu, bir var, let, veya constdeyimindeki bir değişkene atanan bir işlev ifadesinden farklıdır .

Yani mesela,

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Blok kapsamı, tüm bloğu bir fonksiyona sararak ve ardından onu yürüterek (bu, hemen çağrılan fonksiyon ifadesi deseni olarak bilinir) veya letanahtar kelimeyi kullanarak değişkeni bildirerek üretilebilir .

Beyanname ve atama

Kapsam dışında bildirilen değişkenler global içindedir . Bir değişken daha yüksek bir kapsamda bildirilmişse, alt kapsamlar tarafından erişilebilir.

JavaScript bir tanımlayıcıyı çözmeye çalıştığında , yerel kapsamda bakar. Bu tanımlayıcı bulunamazsa, bir sonraki dış kapsama bakar ve bu, global değişkenlerin bulunduğu global kapsama ulaşana kadar kapsam zinciri boyunca devam eder. Hala bulunamazsa, JavaScript bir istisna oluşturacaktır. ReferenceError

Bir tanımlayıcı atarken , JavaScript bu tanımlayıcıyı almak için tamamen aynı süreçten geçer, ancak global kapsamda bulunmazsa , "değişkeni" oluşturulduğu kapsamda oluşturacaktır. Sonuç olarak, hiçbir zaman bildirilmeyen bir değişken atanmışsa global olacaktır. Global kapsamda (yani herhangi bir işlev gövdesinin (veya let/const durumunda blok) dışında var) bir değişken (anahtar sözcüğüyle ) bildirmek, hiçbir zaman bildirilmemiş bir tanımlayıcı atamak veya genel nesneye bir özellik eklemek (genellikle pencere ) ayrıca yeni bir global değişken oluşturun.

JavaScript'in katı modunun , küresel ad alanı kirliliğini önleyen, bildirilmemiş bir değişkenin atanmasını yasakladığını unutmayın .

Örnekler

İşte bazı değişken bildirimleri ve kapsam örnekleri:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

const pi; // throws a SyntaxError: Missing initializer in const declaration

İlkel veri türleri

JavaScript dili altı ilkel veri türü sağlar :

• Tanımsız
• Sayı
• BigInt
• Sicim
• Boole
• Sembol

İlkel veri türlerinden bazıları, tür sınırlarının kapsamlarını temsil eden bir dizi adlandırılmış değer de sağlar. Bu adlandırılmış değerler, aşağıdaki uygun bölümlerde açıklanmıştır.

Tanımsız

"Tanımsız" değeri tüm atanan başlatılmamış değişkenler ve var olmayan nesne özellikleri için kontrol ederken aynı zamanda döndürülür. Boole bağlamında, tanımsız değer yanlış bir değer olarak kabul edilir.

Not: undefined, gerçek bir ilkel tür olarak kabul edilir. Açıkça dönüştürülmediği sürece, tanımsız değer, mantıksal bir bağlamda yanlış olarak değerlendirilen diğer türlere kıyasla beklenmedik şekilde davranabilir.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Not: undefined için yerleşik bir dil değişmezi yoktur. Bu nedenle , bir değişkenin tanımsız olup olmadığını kontrol etmenin kusursuz bir yolu değildir, çünkü ECMAScript 5'ten önceki sürümlerde birinin yazması yasaldır . Daha sağlam bir yaklaşım kullanarak karşılaştırmaktır . (x === undefined)var undefined = "I'm defined now";(typeof x === 'undefined')

Bunun gibi işlevler beklendiği gibi çalışmayacaktır:

function isUndefined(x) { var u; return x === u; }             // like this...
function isUndefined(x) { return x === void 0; }               // ... or that second one
function isUndefined(x) { return (typeof x) === "undefined"; } // ... or that third one

Burada çağıran isUndefined(my_var)bir yükseltir ReferenceError eğer my_var bilinmeyen bir tanımlayıcı ise, değil. typeof my_var === 'undefined'

Sayı

Sayılar, IEEE-754 kayan nokta çiftleri olarak ikili olarak temsil edilir . Bu biçim, yaklaşık 16 anlamlı basamak doğruluğu sağlamasına rağmen , kesirler de dahil olmak üzere gerçek sayıları her zaman tam olarak temsil edemez.

Bu, sayıları karşılaştırırken veya biçimlendirirken bir sorun haline gelir. Örneğin:

console.log(0.2 + 0.1 === 0.3); // displays false
console.log(0.94 - 0.01);       // displays 0.9299999999999999

Sonuç olarak, çıktı için biçimlendirildiklerinde sayıları yuvarlamak için toFixed() yöntemi gibi bir yordam kullanılmalıdır .

Sayılar bu gösterimlerden herhangi birinde belirtilebilir:

345;    // an "integer", although there is only one numeric type in JavaScript
34.5;   // a floating-point number
3.45e2; // another floating-point, equivalent to 345
0b1011; // a binary integer equal to 11
0o377;   // an octal integer equal to 255
0xFF;   // a hexadecimal integer equal to 255, digits represented by the ...
        // ... letters A-F may be upper or lowercase

Ayrıca ES2021'de tanıtılan sayısal bir ayırıcı _ (alt çizgi) vardır:

// Note: Wikipedia syntax doesn't support numeric separators yet
1_000_000_000;    // Used with big numbers
1_000_000.5;      // Support with decimals
1_000e1_000;      // Support with exponents

// Support with binary, octals and hex
0b0000_0000_0101_1011;
0o0001_3520_0237_1327;
0xFFFF_FFFF_FFFF_FFFE;

// But you can't use them next to a non-digit number part, or at the start or end
_12; // Variable is not defined (the underscore makes it a variable identifier)
12_; // Syntax error (cannot be at the end of numbers)
12_.0; // Syntax error (doesn't make sense to put a separator next to the decimal point)
12._0; // Syntax error
12e_6; // Syntax error (next to "e", a non-digit. Doesn't make sense to put a separator at the start)
1000____0000; // Syntax error (next to "_", a non-digit. Only 1 separator at a time is allowed

Sayı türünün +∞ , −∞ ve NaN (Sayı Değil) uzantıları iki program ifadesi ile elde edilebilir:

Infinity; // positive infinity (negative obtained with -Infinity for instance)
NaN;      // The Not-A-Number value, also returned as a failure in ...
          // ... string-to-number conversions

Infinity ve NaN sayılardır:

typeof Infinity;   // returns "number"
typeof NaN;        // returns "number"

Bu üç özel değer, IEEE-754'ün tanımladığı şekilde karşılık gelir ve davranır .

Sayı yapıcısı (bir işlev olarak kullanılır) veya bir tekli + veya -, açık sayısal dönüştürme gerçekleştirmek için kullanılabilir:

var myString = "123.456";
var myNumber1 = Number(myString);
var myNumber2 = +myString;

Yapıcı olarak kullanıldığında, sayısal bir sarmalayıcı nesnesi oluşturulur (çok az kullanılmasına rağmen):

myNumericWrapper = new Number(123.456);

Ancak, NaN kendisine eşit değildir:

const nan = NaN;
console.log(NaN == NaN);        // false
console.log(NaN === NaN);       // false
console.log(NaN !== NaN);       // true
console.log(nan !== nan);       // true

// You can use the isNaN methods to check for NaN
console.log(isNaN("converted to NaN"));     // true
console.log(isNaN(NaN));                    // true
console.log(Number.isNaN("not converted")); // false
console.log(Number.isNaN(NaN));             // true

BigInt

BigInts, keyfi olarak büyük tamsayılar için kullanılabilir . Özellikle JavaScript'in güvenilir şekilde gösterebileceği en büyük sayı olan 2 ⁵³ - 1'den büyük tam sayılar Number.MAX_SAFE_INTEGER sabiti ile temsil edilir.

BigInt'leri bölerken sonuçlar kesilir .

Sicim

JavaScript'te bir dize , bir karakter dizisidir. JavaScript'te, karakter dizileri çift (") veya tek (') tırnak arasına yerleştirerek doğrudan (değişmez olarak) dizeler oluşturulabilir. Bu tür dizeler tek bir satıra yazılmalıdır, ancak çıkış karakterli yeni satır karakterleri (\ gibi) içerebilir. n.) JavaScript standart verir backquote karakterini ( `, nam aksan veya ters tırnak) ile alıntı satırlı edebi dizeleri, ama bu sadece 2016 tarihinden itibaren belirli tarayıcılarda desteklenir: Firefox ve Chrome, ancak Internet Explorer 11.

var greeting = "Hello, World!";
var anotherGreeting = 'Greetings, people of Earth.';

Bir dize içindeki tek tek karakterlere charAt yöntemi ( String.prototype tarafından sağlanır ) kullanılarak erişilebilir . Modern olmayan tarayıcılarda da çalıştığından, bir dize içindeki tek tek karakterlere erişirken tercih edilen yol budur:

var h = greeting.charAt(0);

Modern tarayıcılarda, bir dize içindeki tek tek karakterlere (yalnızca tek karakterli dizeler olarak) dizilerle aynı gösterim yoluyla erişilebilir:

var h = greeting[0];

Ancak, JavaScript dizeleri değişmezdir :

greeting[0] = "H"; // Fails.

Eşitlik operatörünün ("==") iki dizeye uygulanması, dizeler aynı içeriğe sahipse, bunun anlamı: aynı uzunlukta ve aynı karakter dizisini içeriyorsa (harfler için büyük/küçük harf önemlidir). Böylece:

var x = "World";
var compare1 = ("Hello, " +x == "Hello, World"); // Here compare1 contains true.
var compare2 = ("Hello, " +x == "hello, World"); // Here compare2 contains  ...
                                                 // ... false since the ...
                                                 // ... first characters ...
                                                 // ... of both operands ...
                                                 // ... are not of the same case.

Aynı türdeki tırnak işaretleri, kaçmadıkça iç içe geçirilemez .

var x = '"Hello, World!" he said.'; // Just fine.
var x = ""Hello, World!" he said."; //  Not good.
var x = "\"Hello, World!\" he said."; // Works by escaping " with \"

Dize yapıcısı dize nesne (bir nesne bir dize sarma) oluşturur:

var greeting = new String("Hello, World!");

Bu nesneler, içlerine sarılmış ilkel dizeyi döndüren bir valueOf yöntemine sahiptir:

var s = new String("Hello !");
typeof s; // Is 'object'.
typeof s.valueOf(); // Is 'string'.

İki String nesnesi arasındaki eşitlik , dize ilkellerinde olduğu gibi davranmaz:

var s1 = new String("Hello !");
var s2 = new String("Hello !");
s1 == s2; // Is false, because they are two distinct objects.
s1.valueOf() == s2.valueOf(); // Is true.

Boole

JavaScript , true ve false değişmezleri olan bir Boolean veri türü sağlar . Typeof operatörü dize döndürür "boolean" Bunlar için ilkel türleri . Mantıksal bir bağlamda kullanıldığında, 0 , -0 , null , NaN , undefined ve boş dize ( "" ) otomatik tür zorlaması nedeniyle false olarak değerlendirilir . Diğer tüm değerler ( önceki listenin tamamlayıcısı ) , "0" , "false" dizeleri ve herhangi bir nesne dahil olmak üzere true olarak değerlendirilir .

Tür dönüştürme

Eşitlik karşılaştırma operatörleri ( ==ve !=) tarafından otomatik tip zorlaması , tip kontrollü karşılaştırma operatörleri ( ===ve !==) kullanılarak önlenebilir .

Tür dönüştürme gerektiğinde JavaScript, Boolean , Number , String veya Object işlenenlerini aşağıdaki gibi dönüştürür :

Sayı ve Dize

Dize bir sayı değerine dönüştürülür. JavaScript, dize sayısal değişmezini Sayı türü değerine dönüştürmeye çalışır. İlk olarak, dize sayısal değişmezinden matematiksel bir değer türetilir. Daha sonra bu değer, en yakın Sayı türü değerine yuvarlanır.

Boole

İşlenenlerden biri Boolean ise, Boolean işleneni true ise 1'e , false ise 0'a dönüştürülür .

Nesne

Bir nesne bir sayı veya dizeyle karşılaştırılırsa, JavaScript nesne için varsayılan değeri döndürmeye çalışır. Bir nesne, nesnenin .valueOf() veya .toString() yöntemleri kullanılarak ilkel bir Dize veya Sayı değerine dönüştürülür . Bu başarısız olursa, bir çalışma zamanı hatası oluşturulur.

Douglas Crockford , çeşitli türlerdeki değerlerin mantıksal bir bağlamda, özellikle uç durumlarla ilgili olarak değerlendirildiğinde nasıl davrandığını açıklamak için " doğru " ve " yanlış " terimlerini savunur . İkili mantıksal operatörler, JavaScript'in ilk sürümlerinde bir Boole değeri döndürdü, ancak şimdi bunun yerine işlenenlerden birini döndürüyorlar. Sol-işlenen bu olarak değerlendirilebilir eğer döndürülür: FALSE durumunda, birlikte (: a && b) veya doğru olması durumunda, disjunction : ( a || b); aksi takdirde sağ işlenen döndürülür. Karşılaştırma işleçleri tarafından otomatik tür zorlaması, Boolean ve sayı uyumlu işlenenlerin (sayı olarak değerlendirilebilen dizeler veya böyle bir dize olarak değerlendirilebilen nesneler dahil) durumları için farklılık gösterebilir, çünkü Boolean işleneni şu şekilde karşılaştırılacaktır: sayısal bir değer. Bu beklenmedik olabilir. Bir ifade, mantıksal olumsuzlama işleci : ( !! ) iki katına çıkarılarak , Boolean() işlevi kullanılarak veya koşullu işleç : ( c ? t : f) kullanılarak bir Boole ilkel öğesine açıkça dönüştürülebilir .

// Automatic type coercion
console.log(true  ==   2 ); // false... true  → 1 !== 2 ←  2
console.log(false ==   2 ); // false... false → 0 !== 2 ←  2
console.log(true  ==   1 ); // true.... true  → 1 === 1 ←  1
console.log(false ==   0 ); // true.... false → 0 === 0 ←  0
console.log(true  ==  "2"); // false... true  → 1 !== 2 ← "2"
console.log(false ==  "2"); // false... false → 0 !== 2 ← "2"
console.log(true  ==  "1"); // true.... true  → 1 === 1 ← "1"
console.log(false ==  "0"); // true.... false → 0 === 0 ← "0"
console.log(false ==  "" ); // true.... false → 0 === 0 ← ""
console.log(false ==  NaN); // false... false → 0 !== NaN

console.log(NaN == NaN); // false...... NaN is not equivalent to anything, including NaN.

// Type checked comparison (no conversion of types and values)
console.log(true === 1); // false...... data types do not match

// Explicit type coercion
console.log(true === !!2);   // true.... data types and values match
console.log(true === !!0);   // false... data types match, but values differ
console.log( 1  ? true : false); // true.... only ±0 and NaN are "falsy" numbers
console.log("0" ? true : false); // true.... only the empty string is "falsy"
console.log(Boolean({}));    // true.... all objects are "truthy"

Yeni operatör, bir Boolean primitifi için bir nesne sarmalayıcı oluşturmak için kullanılabilir. Bununla birlikte, Typeof operatör dönmez Boole döndürür, nesne sargı için nesne . Tüm nesneler olarak değerlendirmek için gerçek gibi bir yöntem olup .valueOf () veya .ToString () , sarılmış değerini almak için kullanılmalıdır. Boolean türüne açık zorlama için Mozilla , Boolean nesnesi yerine Boolean() işlevinin ( new olmadan ) kullanılmasını önerir .

var b = new Boolean(false);   // Object  false {}
var t = Boolean(b);           // Boolean true
var f = Boolean(b.valueOf()); // Boolean false
var n = new Boolean(b);       // Not recommended
n = new Boolean(b.valueOf()); // Preferred

if (0 || -0 || "" || null || undefined || b.valueOf() || !new Boolean() || !t) {
  console.log("Never this");
} else if ([] && {} && b && typeof b === "object" && b.toString() === "false") {
  console.log("Always this");
}

Sembol

ECMAScript6'da yeni. Bir Sembol benzersiz ve değişmez kimliğidir.

Örnek:

var x = Symbol(1);
var y = Symbol(1);
x === y; // => false

var symbolObject = {};
var normalObject = {};

// since x and y are unique,
// they can be used as unique keys in an object
symbolObject[x] = 1;
symbolObject[y] = 2;

symbolObject[x]; // => 1
symbolObject[y]; // => 2

// as compared to normal numeric keys
normalObject[1] = 1;
normalObject[1] = 2; // overrides the value of 1

normalObject[1]; // => 2

// changing the value of x does not change the key stored in the object
x = Symbol(3);
symbolObject[x]; // => undefined

// changing x back just creates another unique Symbol
x = Symbol(1);
symbolObject[x]; // => undefined

İyi bilinen semboller de vardır .

Bunlardan biri Symbol.iterator; bir şey uygularsa Symbol.iterator, yinelenebilir:

let x = [1, 2, 3, 4]; // x is an Array
x[Symbol.iterator] === Array.prototype[Symbol.iterator]; // and Arrays are iterable

const xIterator = x[Symbol.iterator](); // The [Symbol.iterator] function should provide an iterator for x
xIterator.next(); // { value: 1, done: false }
xIterator.next(); // { value: 2, done: false }
xIterator.next(); // { value: 3, done: false }
xIterator.next(); // { value: 4, done: false }
xIterator.next(); // { value: undefined, done: true }
xIterator.next(); // { value: undefined, done: true }

// for..of loops automatically iterate values
for (const value of x) {
   console.log(value); // 1 2 3 4
}

// Sets are also iterable:
[Symbol.iterator] in Set.prototype; // true

for (const value of new Set(['apple', 'orange'])) {
   console.log(value); // "apple" "orange"
}

Yerel nesneler

JavaScript dili, bir avuç yerel nesne sağlar . JavaScript yerel nesneleri, JavaScript belirtiminin bir parçası olarak kabul edilir. JavaScript ortamına rağmen, bu nesne kümesi her zaman kullanılabilir olmalıdır.

Dizi

Bir dizi örneklenmekte bir JavaScript amacı, Dizi özellikle tam sayı tuşları ile endeksli depolamak veri değerleri için tasarlanmış kurucu. Diziler, temel Nesne türünden farklı olarak, programcıya rutin görevlerde (örneğin, birleştirme , dilim ve itme ) yardımcı olmak için yöntemler ve özelliklerle prototiplenir .

Gibi C ailesi , sıralar bir sıfır esaslı indeks düzenlemesi kullanımı: vasıtasıyla boş bir dizi takılan bir değer itme yöntemi dizinin 0. endeksi kaplar.

var myArray = [];            // Point the variable myArray to a newly ...
                             // ... created, empty Array
myArray.push("hello World"); // Fill the next empty index, in this case 0
console.log(myArray[0]);           // Equivalent to console.log("hello World");

Diziler, her zaman dizide kullanılan en büyük tamsayı dizininden daha büyük olması garanti edilen bir uzunluk özelliğine sahiptir. Daha da büyük bir dizine sahip bir özellik oluşturulursa, otomatik olarak güncellenir. length özelliğine daha küçük bir sayı yazmak, daha büyük dizinleri kaldıracaktır.

Unsurları Dizi s, normal nesne özelliği erişim gösterimi kullanılarak erişilebilir:

myArray[1];  // the 2nd item in myArray
myArray["1"];

Yukarıdaki ikisi eşdeğerdir. Sayının alternatif temsilleriyle "nokta" gösterimini veya dizelerini kullanmak mümkün değildir:

myArray.1;     // syntax error
myArray["01"]; // not the same as myArray[1]

Bir dizinin bildirimi, bir Array değişmez değerini veya Array yapıcısını kullanabilir:

let myArray;

// Array literals
myArray = [1, 2]; // length of 2
myArray = [1, 2,]; // same array - You can also have an extra comma at the end

// It's also possible to not fill in parts of the array
myArray = [0, 1, /* hole */, /* hole */, 4, 5]; // length of 6
myArray = [0, 1, /* hole */, /* hole */, 4, 5,]; // same array
myArray = [0, 1, /* hole */, /* hole */, 4, 5, /* hole */,]; // length of 7

// With the constructor
myArray = new Array(0, 1, 2, 3, 4, 5); // length of 6
myArray = new Array(365);              // an empty array with length 365

Diziler , yalnızca tanımlanan öğelerin belleği kullanması için uygulanır; onlar " seyrek diziler " dir. Ayarlama ve yalnızca bu iki öğe için boşluk kullanır, tıpkı diğer nesneler gibi. Dizinin uzunluğu yine 58 olarak bildirilecektir. Bir dizinin maksimum uzunluğu 4,294,967,295 olup, bu, 32 bitlik ikili sayıya (111111111111111111111111111111) ₂ . myArray[10] = 'someThing'myArray[57] = 'somethingOther'

Diğer dillerdeki ilişkisel diziler gibi davranan nesneler oluşturmak için nesne bildirimi değişmezi kullanılabilir:

dog = {color: "brown", size: "large"};
dog["color"]; // results in "brown"
dog.color;    // also results in "brown"

İlişkili, çok boyutlu veya her ikisi birden olan dizileri hızlı bir şekilde oluşturmak için nesne ve dizi bildirimi değişmezleri kullanılabilir. (Teknik olarak, JavaScript çok boyutlu dizileri desteklemez, ancak dizi dizileriyle taklit edilebilir.)

cats = [{color: "brown", size: "large"},
    {color: "black", size: "small"}];
cats[0]["size"];      // results in "large"

dogs = {rover: {color: "brown", size: "large"},
    spot: {color: "black", size: "small"}};
dogs["spot"]["size"]; // results in "small"
dogs.rover.color;     // results in "brown"

Tarih

Bir Date nesnesi, sıfır 1970-01-01 00:00:00 UT'yi ve ±10 ⁸ gün aralığını temsil eden imzalı bir milisaniye sayısını depolar . Date yapıcısına argüman sağlamanın birkaç yolu vardır . Ayların sıfır tabanlı olduğunu unutmayın.

new Date();                       // create a new Date instance representing the current time/date.
new Date(2010, 2, 1);             // create a new Date instance representing 2010-Mar-01 00:00:00
new Date(2010, 2, 1, 14, 25, 30); // create a new Date instance representing 2010-Mar-01 14:25:30
new Date("2010-3-1 14:25:30");    // create a new Date instance from a String.

Alanları ayıklama yöntemlerinin yanı sıra yararlı bir toString :

var d = new Date(2010, 2, 1, 14, 25, 30); // 2010-Mar-01 14:25:30;

// Displays '2010-3-1 14:25:30':
console.log(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate() + ' '
    + d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());

// Built-in toString returns something like 'Mon Mar 01 2010 14:25:30 GMT-0500 (EST)':
console.log(d);

Hata

Error sınıfı kullanılarak özel hata mesajları oluşturulabilir :

throw new Error("Something went wrong.");

Bunlar, istisna işleme bölümünde açıklandığı gibi try...catch...finally blokları tarafından yakalanabilir .

Matematik

Matematik bir amacı, çeşitli matematik ilgili (örneğin, sabitleri içerir π ) ve işlevler (örneğin, kosinüs). (Not bu Math nesnesi hiçbir yapıcı, aksine sahip Diziyi veya tarihi Tüm trigonometrik fonksiyonlar cinsinden ifade açıları kullanmak "sınıfı" yöntemleri. Olduğunu. Tüm onun yöntemlerdir "statik",) radyan değil derece veya grad .

Düzenli ifade

/expression/.test(string);     // returns Boolean
"string".search(/expression/); // returns position Number
"string".replace(/expression/, replacement);

// Here are some examples
if (/Tom/.test("My name is Tom")) console.log("Hello Tom!");
console.log("My name is Tom".search(/Tom/));          // == 11 (letters before Tom)
console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"

Karakter sınıfları

// \d  - digit
// \D  - non digit
// \s  - space
// \S  - non space
// \w  - word char
// \W  - non word
// [ ] - one of
// [^] - one not of
//  -  - range

if (/\d/.test('0'))                   console.log('Digit');
if (/[0-9]/.test('6'))                console.log('Digit');
if (/[13579]/.test('1'))              console.log('Odd number');
if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK');
if (/\w\w\w/.test('Tom'))             console.log('Hello Tom');
if (/[a-zA-Z]/.test('B'))             console.log('Letter');

Karakter eşleştirme

// A...Z a...z 0...9  - alphanumeric
// \u0000...\uFFFF    - Unicode hexadecimal
// \x00...\xFF        - ASCII hexadecimal
// \t                 - tab
// \n                 - new line
// \r                 - CR
// .                  - any character
// |                  - OR

if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim');
if (/A|B/.test("A"))  console.log ('A or B');

Tekrarlayıcılar

// ?   - 0 or 1 match
// *   - 0 or more
// +   - 1 or more
// {n}   - exactly n
// {n,}  - n or more
// {0,n} - n or less
// {n,m} - range n to m

if (/ab?c/.test("ac"))       console.log("OK"); // match: "ac", "abc"
if (/ab*c/.test("ac"))       console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc.
if (/ab+c/.test("abc"))      console.log("OK"); // match: "abc", "abbc", "abbbc" etc.
if (/ab{3}c/.test("abbbc"))  console.log("OK"); // match: "abbbc"
if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc", "abbbbc", "abbbbbc" etc.
if (/ab{1,3}c/.test("abc"))  console.log("OK"); // match: "abc", "abbc", "abbbc"

çapalar

// ^  - string starts with
// $  - string ends with

if (/^My/.test("My name is Tom"))   console.log ("Hi!");
if (/Tom$/.test("My name is Tom"))  console.log ("Hi Tom!");

alt ifade

// ( )  - groups characters

if (/water(mark)?/.test("watermark")) console.log("Here is water!"); // match: "water", "watermark",
if (/(Tom)|(John)/.test("John"))      console.log("Hi Tom or John!");

Bayraklar

// /g  - global
// /i  - ignore upper/lower case
// /m  - allow matches to span multiple lines

console.log("hi tom!".replace(/Tom/i, "John"));  // == "hi John!"
console.log("ratatam".replace(/ta/, "tu"));      // == "ratutam"
console.log("ratatam".replace(/ta/g, "tu"));     // == "ratutum"

Gelişmiş yöntemler

my_array = my_string.split(my_delimiter);
// example
my_array = "dog,cat,cow".split(",");      // my_array==["dog","cat","cow"];

my_array = my_string.match(my_expression);
// example
my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g); // my_array==["11:30","12:15","16:45"];

Grupları yakalama

var myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/;
var results = myRe.exec("The date and time are 2009-09-08 09:37:08.");
if (results) {
  console.log("Matched: " + results[0]); // Entire match
  var my_date = results[1]; // First group == "2009-09-08"
  var my_time = results[2]; // Second group == "09:37:08"
  console.log("It is " + my_time + " on " + my_date);
} else console.log("Did not find a valid date!");

İşlev

JavaScript'teki her işlev, İşlev yapıcısının bir örneğidir :

// x, y is the argument. 'return x + y' is the function body, which is the last in the argument list.
var add = new Function('x', 'y', 'return x + y');
add(1, 2); // => 3

Yukarıdaki ekleme işlevi, bir işlev ifadesi kullanılarak da tanımlanabilir:

var add = function(x, y) {
  return x + y;
};
add(1, 2); // => 3

ES6'da, bir değer döndüren işlevlerin daha kısa olmasına izin veren ok işlevi sözdizimi eklendi. Ayrıca , function() {} ifadesinin aksine, çağrıldığı yerden / çağrıldığı yerden miras almak yerine global nesnenin bu özelliğini korurlar .

var add = (x, y) => {return x + y;};
// values can also be implicitly returned (i.e. no return statement is needed)
var addImplicit = (x, y) => x + y;

add(1, 2); // => 3
addImplicit(1, 2) // => 3

Kaldırılması gereken işlevler için ayrı bir ifade vardır:

function add(x, y) {
  return x + y;
}
add(1, 2); // => 3

Kaldırma, işlevi "bildirilmeden" önce kullanmanıza olanak tanır:

add(1, 2); // => 3, not a ReferenceError
function add(x, y) {
  return x + y;
}

Bir işlev örneğinin özellikleri ve yöntemleri vardır.

function subtract(x, y) {
  return x - y;
}

console.log(subtract.length); // => 2, arity of the function (number of arguments)
console.log(subtract.toString());

/*
"function subtract(x, y) {
  return x - y;
}"
*/

operatörler

'+' operatörü aşırı yüklenmiştir : dizi birleştirme ve aritmetik toplama için kullanılır. Bu, dizeleri ve sayıları yanlışlıkla karıştırırken sorunlara neden olabilir. Birli operatör olarak, sayısal bir dizgiyi sayıya dönüştürebilir.

// Concatenate 2 strings
console.log('He' + 'llo'); // displays Hello

// Add two numbers
console.log(2 + 6);  // displays 8

// Adding a number and a string results in concatenation (from left to right)
console.log(2 + '2');    // displays 22
console.log('$' + 3 + 4);  // displays $34, but $7 may have been expected
console.log('$' + (3 + 4)); // displays $7
console.log(3 + 4 + '7'); // displays 77, numbers stay numbers until a string is added

// Convert a string to a number using the unary plus
console.log(+'2' === 2); // displays true
console.log(+'Hello'); // displays NaN

Benzer şekilde, '*' operatörü aşırı yüklenmiştir: bir dizgiyi sayıya dönüştürebilir.

console.log(2 + '6'*1);  // displays 8
console.log(3*'7'); // 21
console.log('3'*'7'); // 21
console.log('hello'*'world'); // displays NaN

Aritmetik

JavaScript aşağıdaki ikili aritmetik operatörleri destekler :

JavaScript, aşağıdaki tekli aritmetik operatörleri destekler :

var x = 1;
console.log(++x); // x becomes 2; displays 2
console.log(x++); // displays 2; x becomes 3
console.log(x);  // x is 3; displays 3
console.log(x--); //  displays 3; x becomes 2
console.log(x);  //  displays 2; x is 2
console.log(--x); //  x becomes 1; displays 1

Modulo operatörü, modüle bölündükten sonra kalanı görüntüler. Negatif sayılar söz konusuysa, döndürülen değer işlenene bağlıdır.

var x = 17;
console.log(x%5); // displays 2
console.log(x%6); // displays 5
console.log(-x%5); // displays -2
console.log(-x%-5); // displays -2
console.log(x%-5); // displays 2

Her zaman negatif olmayan bir sayı döndürmek için modülü yeniden ekleyin ve modulo operatörünü tekrar uygulayın:

var x = 17;
console.log((-x%5+5)%5); // displays 3

Atama

Atama arasında basit türler

var x = 9;
x += 1; 
console.log(x); // displays: 10
x *= 30;
console.log(x); // displays: 300
x /= 6;
console.log(x); // displays: 50
x -= 3;
console.log(x); // displays: 47
x %= 7;
console.log(x); // displays: 5

Nesne türlerinin atanması

/**
 * To learn JavaScript objects...
 */
var object_1 = {a: 1};		// assign reference of newly created object to object_1
var object_2 = {a: 0};
var object_3 = object_2;	// object_3 references the same object as object_2 does
	 
object_3.a = 2;
message();	        	// displays 1 2 2
	 
object_2 = object_1;		// object_2 now references the same object as object_1
	        	        // object_3 still references what object_2 referenced before
message();		        // displays 1 1 2
	 
object_2.a = 7;  	        // modifies object_1
message();		        // displays 7 7 2

object_3.a = 5;                 // object_3 doesn't change object_2
message();	                // displays 7 7 5

object_3 = object_2;	
object_3.a=4;                  // object_3 changes object_1 and object_2
message();                     // displays 4 4 4

/**
 * Prints the console.log message
 */
function message() {
	console.log(object_1.a + " " + object_2.a + " " + object_3.a);
}

yıkım ataması

Mozilla'nın JavaScript'inde, sürüm 1.7'den bu yana, yıkım ataması, veri yapılarının bölümlerinin aynı anda birkaç değişkene atanmasına izin verir. Bir atamanın sol tarafı, yapraklarında atanan değerin alt yapılarını alacak olan l-değerlerini içeren, keyfi olarak yuvalanmış bir nesne/dizi değişmezine benzeyen bir kalıptır.

var a, b, c, d, e;
[a, b, c] = [3, 4, 5];
console.log(a + ',' + b + ',' + c); // displays: 3,4,5
e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};
var arr = [];
({baz: [arr[0], arr[3]], foo: a, bar: b}) = e;
console.log(a + ',' + b + ',' + arr);	// displays: 5,6,Baz,,,Content
[a, b] = [b, a];		// swap contents of a and b
console.log(a + ',' + b);		// displays: 6,5

[a, b, c] = [3, 4, 5]; // permutations
[a, b, c] = [b, c, a];
console.log(a + ',' + b + ',' + c); // displays: 4,5,3

Yayma/dinlenme operatörü

ECMAScript 2015 standardı , ilgili "yayılmış sözdizimi" ve "dinlenme parametreleri" kavramları için " ... " operatörünü sunar.

Yayılmış sözdizimi , dizileri yok etmenin başka bir yolunu sağlar. Belirtilen dizideki öğelerin, bir işlev çağrısındaki parametreler veya bir dizi değişmezindeki öğeler olarak kullanılması gerektiğini belirtir.

Başka bir deyişle, " ... ", " [...foo] " öğesini " [foo[0], foo[1], foo[2]] " ve " this.bar(...foo); " içine " this.bar(foo[0], foo[1], foo[2]); ".

var a = [1, 2, 3, 4];

// It can be used multiple times in the same expression
var b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];

// It can be combined with non-spread items.
var c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];

// For comparison, doing this without the spread operator 
// creates a nested array.
var d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]

// It works the same with function calls
function foo(arg1, arg2, arg3) {
    console.log(arg1 + ':' + arg2 + ':' + arg3);
}

// You can use it even if it passes more parameters than the function will use
foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

// You can mix it with non-spread parameters
foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

// For comparison, doing this without the spread operator
// assigns the array to arg1, and nothing to the other parameters.
foo(a); // "1,2,3,4:undefined:undefined"

Bir işlev bildiriminde ... kullanıldığında, bir dinlenme parametresini belirtir . rest parametresi, işlevin parametre listesindeki son adlandırılmış parametre olmalıdır. Diğer adlandırılmış parametreleri aşan işleve iletilen herhangi bir bağımsız değişkeni içeren bir Dizi atanacaktır . Başka bir deyişle, işleve iletilen argümanların "geri kalanını" alır (dolayısıyla adı).

function foo(a, b, ...c) {
    console.log(c.length);
}

foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]
foo('a', 'b'); // "0" → c = []

Rest parametreleri , geçerli işlev çağrısındaki tüm parametreleri (adlandırılmış ve adsız) içeren dizi benzeri bir nesne olan Javascript'in argümans nesnesine benzer . Ancak argümanların aksine , rest parametreleri true Array nesneleridir, bu nedenle .slice() ve .sort() gibi yöntemler doğrudan bunlar üzerinde kullanılabilir.

... operatörü yalnızca kullanılabilir Dizi nesneler. (Ancak, gelecekteki bir ECMAScript standardında bunu Object s'ye genişletmek için bir teklif var .)

Karşılaştırmak

Nesnelere başvuruda bulunan değişkenler, yalnızca aynı nesneye başvuruyorlarsa eşit veya özdeştir:

var obj1 = {a: 1};
var obj2 = {a: 1};
var obj3 = obj1;
console.log(obj1 == obj2);  //false
console.log(obj3 == obj1);  //true
console.log(obj3 === obj1); //true

Ayrıca bkz Dize .

Mantıklı

JavaScript dört mantıksal operatör sağlar:

• tekli olumsuzlama ( NOT = !a )
• ikili ayrılma ( OR = a || b ) ve bağlaç ( AND = a && b )
• üçlü koşullu ( c ? t : f )

Mantıksal bir işlem bağlamında, aşağıdakiler dışında herhangi bir ifade true olarak değerlendirilir :

• Dizeler: "" , '' ,
• Sayılar: 0 , -0 , NaN ,
• Özel: null , tanımsız ,
• Boole: yanlış .

Boolean işlevi, Boolean türünde bir ilkel öğeye açıkça dönüştürmek için kullanılabilir :

// Only empty strings return false
console.log(Boolean("")      === false);
console.log(Boolean("false") === true);
console.log(Boolean("0")     === true);

// Only zero and NaN return false
console.log(Boolean(NaN) === false);
console.log(Boolean(0)   === false);
console.log(Boolean(-0)  === false); // equivalent to -1*0
console.log(Boolean(-2)  === true);

// All objects return true
console.log(Boolean(this) === true);
console.log(Boolean({})   === true);
console.log(Boolean([])   === true);

// These types return false
console.log(Boolean(null)      === false);
console.log(Boolean(undefined) === false); // equivalent to Boolean()

NOT operatörü, işlenenini Boolean olarak değerlendirir ve olumsuzlamayı döndürür. Operatörü çift ​​negatif olarak arka arkaya iki kez kullanmak, bir ifadeyi açıkça Boolean türünde bir ilkele dönüştürür:

console.log( !0 === Boolean(!0));
console.log(Boolean(!0) === !!1);
console.log(!!1 === Boolean(1));
console.log(!!0 === Boolean(0));
console.log(Boolean(0) === !1);
console.log(!1 === Boolean(!1));
console.log(!"" === Boolean(!""));
console.log(Boolean(!"") === !!"s");
console.log(!!"s" === Boolean("s"));
console.log(!!"" === Boolean(""));
console.log(Boolean("") === !"s");	
console.log(!"s" === Boolean(!"s"));

Üçlü operatör, açık dönüştürme için de kullanılabilir:

console.log([] == false); console.log([] ? true : false); // “truthy”, but the comparison uses [].toString()
console.log([0] == false); console.log([0]? true : false); // [0].toString() == "0"
console.log("0" == false); console.log("0"? true : false); // "0" → 0 ... (0 == 0) ... 0 ← false
console.log([1] == true); console.log([1]? true : false); // [1].toString() == "1"
console.log("1" == true); console.log("1"? true : false); // "1" → 1 ... (1 == 1) ... 1 ← true
console.log([2] != true); console.log([2]? true : false); // [2].toString() == "2"
console.log("2" != true); console.log("2"? true : false); // "2" → 2 ... (2 != 1) ... 1 ← true

Arttırma sonrası ( i++ ) gibi özellikleri kullanan ifadelerin beklenen bir yan etkisi vardır . JavaScript, ifadelerin kısa devre değerlendirmesini sağlar ; sağ işlenen, yalnızca sol işlenen, ifadenin değerini belirlemek için yeterli değilse yürütülür.

console.log(a || b);  // When a is true, there is no reason to evaluate b.
console.log(a && b);  // When a is false, there is no reason to evaluate b.
console.log(c ? t : f); // When c is true, there is no reason to evaluate f.

JavaScript ve JScript'in ilk sürümlerinde , ikili mantıksal operatörler bir Boole değeri döndürdü (çoğu C'den türetilmiş programlama dili gibi). Ancak, tüm çağdaş uygulamalar bunun yerine işlenenlerinden birini döndürür:

console.log(a || b); // if a is true, return a, otherwise return b
console.log(a && b); // if a is false, return a, otherwise return b

C'deki davranışa daha aşina olan programcılar bu özelliği şaşırtıcı bulabilir, ancak bu, boş birleştirme gibi kalıpların daha özlü bir ifadesine izin verir :

var s = t || "(default)"; // assigns t, or the default value, if t is null, empty, etc.

mantıksal atama

bit düzeyinde

JavaScript, aşağıdaki ikili bit düzeyinde operatörleri destekler :

Örnekler:

x=11 & 6;
console.log(x); // 2

JavaScript, aşağıdaki tekli bit düzeyinde operatörü destekler :

Bitsel Atama

JavaScript, aşağıdaki ikili atama operatörlerini destekler :

Örnekler:

x=7;
console.log(x); // 7
x<<=3;
console.log(x); // 7->14->28->56

Sicim

Örnekler:

str = "ab" + "cd";  // "abcd"
str += "e";      // "abcde"

str2 = "2" + 2;     // "22", not "4" or 4.

??

const a = b ?? 3;

const a = b || 3;

Kontrol Yapıları

Bileşik ifadeler

Bir çift küme parantez { } ve kapalı bir ifade dizisi, bir ifadenin kullanılabildiği her yerde kullanılabilen bir bileşik ifade oluşturur.

eğer ... başka

if (expr) {
  //statements;
} else if (expr2) {
  //statements;
} else {
  //statements;
}

Koşullu (üçlü) operatör

Koşul operatörü, bir koşula bağlı olarak iki ifadeden biri olarak değerlendirilen bir ifade oluşturur. Bu, bir koşula bağlı olarak yürütülecek iki ifadeden birini seçen if ifadesine benzer . Yani, koşul operatörü ifadelere , if ifadelerine ise.

 result = condition ? expression : alternative;

aynıdır:

 if (condition) {
  result = expression;
 } else {
  result = alternative;
 }

if ifadesinin aksine, koşul operatörü "else-dal" öğesini atlayamaz.

ifadeyi değiştir

JavaScript switch ifadesinin sözdizimi aşağıdaki gibidir:

 switch (expr) {
  case SOMEVALUE:
   // statements;
   break;
  case ANOTHERVALUE:
   // statements;
   break;
  default:
   // statements;
   break;
 }

• kırmak; İsteğe bağlı; ancak, aksi takdirde kod yürütme bir sonraki vaka bloğunun gövdesine devam edeceğinden genellikle gereklidir.
• Daha sonra ek vakaların eklenmesi durumunda, önlem olarak son vakanın sonuna bir break ifadesi ekleyin.
• Durum değerleri için dize değişmez değerleri de kullanılabilir.
• Değerler yerine ifadeler kullanılabilir.
• Varsayılan durum (isteğe bağlı), ifade belirtilen diğer durumlarla eşleşmediğinde yürütülür.
• Braketler gereklidir.

Döngü için

JavaScript for döngüsünün sözdizimi aşağıdaki gibidir:

 for (initial; condition; loop statement) {
  /*
   statements will be executed every time
   the for{} loop cycles, while the
   condition is satisfied
  */
 }

veya

 for (initial; condition; loop statement(iteration)) // one statement

için ... döngüde

JavaScript'in sözdizimi for ... in loopaşağıdaki gibidir:

for (var property_name in some_object) {
  // statements using some_object[property_name];
}

• Bir nesnenin tüm numaralandırılabilir özelliklerini yineler.
• Varsa, dizi nesnesinin tüm kullanıcı tanımlı özellikleri dahil olmak üzere dizinin kullanılan tüm dizinlerini yineler. Bu nedenle, diziler üzerinde yineleme yaparken sayısal indeksli geleneksel bir for döngüsü kullanmak daha iyi olabilir.
• Çeşitli Web tarayıcıları arasında, for...in döngüsü deyimiyle hangi özelliklerin yansıtılacağına ilişkin farklılıklar vardır. Teoride bu, "DontEnum" adı verilen ECMAscript standardı tarafından tanımlanan bir dahili durum özelliği tarafından kontrol edilir, ancak pratikte her tarayıcı, iç gözlem sırasında biraz farklı bir özellik kümesi döndürür. Belirli bir özelliği } kullanarak test etmek yararlıdır . Bu nedenle, dizi prototipine } ile bir yöntem eklemek, döngülerin yöntemin adı üzerinde dönmesine neden olabilir .if (some_object.hasOwnProperty(property_name)) { ...Array.prototype.newMethod = function() {...for ... in

Döngü sırasında

JavaScript while döngüsünün sözdizimi aşağıdaki gibidir:

while (condition) {
  statement1;
  statement2;
  statement3;
  ...
}

Do ... while döngüsü

JavaScript'in sözdizimi do ... while loopaşağıdaki gibidir:

do {
  statement1;
  statement2;
  statement3;
  ...
} while (condition);

İle birlikte

with ifadesi, verilen nesnenin tüm özelliklerini ve yöntemlerini aşağıdaki bloğun kapsamına ekler ve bunlara yerel değişkenlermiş gibi başvurulmasına izin verir.

with (document) {
  var a = getElementById('a');
  var b = getElementById('b');
  var c = getElementById('c');
};

• Belgenin yokluğuna dikkat edin . her getElementById() çağrısından önce .

Anlambilim, Pascal'ın with deyimine benzer .

(Herhangi bir değişken aslında bir kapatmakta bir özellik olabilir çünkü kod netlik azalttığına inanılan tabloların doğruluğu engel olması olarak programın performansı ile ve kullanılabilirliği Çünkü ile ), bu açıklama yasaktır Katı modda .

Etiketler

JavaScript, çoğu uygulamada iç içe etiketleri destekler. Döngüler veya bloklar için break deyimi için etiketlenmiş ve döngüler edilebilir devam . goto ayrılmış bir kelime olmasına rağmen , goto JavaScript'te uygulanmaz.

loop1: for (var a = 0; a < 10; a++) {
  if (a == 4) {
    break loop1; // Stops after the 4th attempt
  }
  console.log('a = ' + a);
  loop2: for (var b = 0; b < 10; ++b) {
    if (b == 3) {
     continue loop2; // Number 3 is skipped
    }
    if (b == 6) {
     continue loop1; // Continues the first loop, 'finished' is not shown
    }
    console.log('b = ' + b);
  }
  console.log('finished');
}
block1: {
  console.log('Hello'); // Displays 'Hello'
  break block1;
  console.log('World'); // Will never get here
}
goto block1; // Parse error.

Fonksiyonlar

Bir fonksiyon , normalde bir isim verilen (muhtemelen boş) parametre listesine sahip bir bloktur. Bir fonksiyon yerel değişkenler kullanabilir. İşlevden bir dönüş ifadesi olmadan çıkarsanız, tanımsız değeri döndürülür.

function gcd(segmentA, segmentB) {
  var diff = segmentA - segmentB;
  if (diff == 0) 
    return segmentA;
  return diff > 0 ? gcd(segmentB, diff) : gcd(segmentA, -diff);
}
console.log(gcd(60, 40)); // 20

var mygcd = gcd; // mygcd is a reference to the same function as gcd. Note no argument ()s.
console.log(mygcd(60, 40)); // 20

Fonksiyonlar birinci sınıf nesnelerdir ve diğer değişkenlere atanabilirler.

Bir fonksiyon çağrılırken verilen argümanların sayısı, fonksiyon tanımındaki argümanların sayısına mutlaka karşılık gelmeyebilir; çağrıda eşleşen bir bağımsız değişkene sahip olmayan tanımdaki adlandırılmış bir bağımsız değişken, undefined değerine sahip olacaktır (bu, dolaylı olarak false değerine dönüştürülebilir ). İşlev içinde, argümanlara argümanlar nesnesi aracılığıyla da erişilebilir ; bu, adlandırılmış bağımsız değişken sayısının ötesinde olanlar da dahil olmak üzere, dizinleri (örn. ) kullanan tüm bağımsız değişkenlere erişim sağlar . (Argüman listesi bir .length özelliğine sahip olsa da , bu bir Array örneği değildir ; .slice() , .sort() vb. gibi yöntemleri yoktur .) arguments[0], arguments[1], ... arguments[n]

function add7(x, y) {
  if (!y) {
    y = 7;
  }
  console.log(x + y + arguments.length);
};
add7(3); // 11
add7(3, 4); // 9

İlkel değerler (sayı, boolean, string) değere göre iletilir. Nesneler için, iletilen nesneye yapılan başvurudur.

var obj1 = {a : 1};
var obj2 = {b : 2};
function foo(p) {
  p = obj2; // Ignores actual parameter
  p.b = arguments[1];
}
foo(obj1, 3); // Does not affect obj1 at all. 3 is additional parameter
console.log(obj1.a + " " + obj2.b); // writes 1 3

İşlevler, diğer işlevlerin içinde bildirilebilir ve dış işlevin yerel değişkenlerine erişebilir. Ayrıca, dış fonksiyon çıktıktan sonra bile dış fonksiyonun yerel değişkenlerini hatırlayarak tam kapatmalar uygularlar.

var v = "Top";
var bar, baz;
function foo() {
  var v = "fud";
  bar = function() { console.log(v) };
  baz = function(x) { v = x; };
}
foo();
baz("Fugly");
bar(); // Fugly (not fud) even though foo() has exited.
console.log(v); // Top

zaman uyumsuz/bekliyor

async function createNewDoc() {
  let response = await db.post({}); // post a new doc
  return await db.get(response.id); // find by id
}

async function main() {
  try {
    let doc = await createNewDoc();
    console.log(doc);
  } catch (err) {
    console.log(err);
  }
}
main();

nesneler

Kolaylık sağlamak için, türler normalde ilkellere ve nesnelere bölünür . Nesneler, bir kimliğe sahip (yalnızca kendilerine eşittirler) ve özellik adlarını değerlerle eşleyen varlıklardır ( prototip tabanlı programlama terminolojisinde "yuvalar" ). Nesneler, ilişkisel diziler veya karmalar olarak düşünülebilir ve genellikle bu veri yapıları kullanılarak uygulanır. Ancak nesnelerin, sıradan ilişkisel dizilerin sahip olmadığı prototip zinciri gibi ek özellikleri vardır.

JavaScript'te Array , Boolean , Date , Function , Math , Number , Object , RegExp ve String gibi çeşitli yerleşik nesneler bulunur . Diğer nesneler, dil tarafından değil, çalışma zamanı ortamı tarafından tanımlanan "ana bilgisayar nesneleridir". Örneğin, bir tarayıcıda, tipik ana bilgisayar nesneleri DOM'a aittir (pencere, form, bağlantılar vb.).

Nesne oluşturma

Nesneler, bir kurucu veya bir nesne değişmezi kullanılarak oluşturulabilir. Yapıcı, yerleşik bir Nesne işlevi veya özel bir işlev kullanabilir. Yapıcı işlevlerine büyük harfle başlayan bir ad verilmesi bir kuraldır:

// Constructor
var anObject = new Object();

// Object literal
var objectA = {};
var objectA2 = {};  // A != A2, {}s create new objects as copies.
var objectB = {index1: 'value 1', index2: 'value 2'};

// Custom constructor (see below)

Nesne değişmezleri ve dizi değişmezleri, birinin kolayca esnek veri yapıları oluşturmasını sağlar:

var myStructure = {
  name: {
    first: "Mel",
    last: "Smith"
  },
  age: 33,
  hobbies: ["chess", "jogging"]
};

Bu, veri alışverişi için JavaScript benzeri sözdizimi kullanan basit bir gösterim olan JSON'un temelidir .

yöntemler

Bir yöntem, sadece, bir nesnenin bir özelliği adı tahsis edilmiş olan bir fonksiyondur. Birçok nesne yönelimli dilden farklı olarak, nesneyle ilgili JavaScript'te işlev tanımı ile yöntem tanımı arasında bir ayrım yoktur. Bunun yerine, işlev çağrısı sırasında ayrım oluşur; bir işlev, bir yöntem olarak çağrılabilir.

Bir yöntem olarak çağrıldığında, standart yerel değişken bu , " . " öğesinin solundaki nesne örneğine otomatik olarak ayarlanır . (Ayrıca vardır diyoruz ve uygulamak ayarlayabilirsiniz yöntemleri bu açıkça-bazı gibi paketler jQuery ile sıradışı şeyler yapmak bu .)

Aşağıdaki örnekte, yapıcı olarak Foo kullanılmaktadır. Bir kurucu hakkında özel bir şey yoktur - sadece bir nesneyi başlatan düz bir işlevdir. Norm olduğu gibi new anahtar sözcüğüyle birlikte kullanıldığında bu , yeni oluşturulan boş bir nesneye ayarlanır.

Aşağıdaki örnekte, Foo'nun yuvalara, bazıları işlev olan değerler atadığını unutmayın. Böylece farklı örneklere farklı işlevler atayabilir. Bu örnekte prototipleme yoktur.

function px() { return this.prefix + "X"; }

function Foo(yz) {
  this.prefix = "a-";
  if (yz > 0) {
    this.pyz = function() { return this.prefix + "Y"; };
  } else {
    this.pyz = function() { return this.prefix + "Z"; };
  }
  this.m1 = px;
  return this;
}

var foo1 = new Foo(1);
var foo2 = new Foo(0);
foo2.prefix = "b-";

console.log("foo1/2 " + foo1.pyz() + foo2.pyz());
// foo1/2 a-Y b-Z

foo1.m3 = px; // Assigns the function itself, not its evaluated result, i.e. not px()
var baz = {"prefix": "c-"};
baz.m4 = px; // No need for a constructor to make an object.

console.log("m1/m3/m4 " + foo1.m1() + foo1.m3() + baz.m4());
// m1/m3/m4 a-X a-X c-X

foo1.m2(); // Throws an exception, because foo1.m2 doesn't exist.

yapıcılar

Yapıcı işlevleri , yeni oluşturulan bir nesnenin yuvalarına basitçe değerler atar. Değerler veri veya diğer işlevler olabilir.

Örnek: Bir nesneyi manipüle etme:

function MyObject(attributeA, attributeB) {
  this.attributeA = attributeA;
  this.attributeB = attributeB;
}

MyObject.staticC = "blue"; // On MyObject Function, not object
console.log(MyObject.staticC); // blue

object = new MyObject('red', 1000);

console.log(object.attributeA); // red
console.log(object["attributeB"]); // 1000

console.log(object.staticC); // undefined
object.attributeC = new Date(); // add a new property

delete object.attributeB; // remove a property of object
console.log(object.attributeB); // undefined

delete object; // remove the whole Object (rarely used)
console.log(object.attributeA); // throws an exception

Yapıcının kendisine, nesnenin prototipinin yapıcı yuvasında başvurulur . Yani,

function Foo() {}
// Use of 'new' sets prototype slots (for example, 
// x = new Foo() would set x's prototype to Foo.prototype,
// and Foo.prototype has a constructor slot pointing back to Foo).
x = new Foo();
// The above is almost equivalent to
y = {};
y.constructor = Foo;
y.constructor();
// Except
x.constructor == y.constructor // true
x instanceof Foo // true
y instanceof Foo // false
// y's prototype is Object.prototype, not
// Foo.prototype, since it was initialised with
// {} instead of new Foo.
// Even though Foo is set to y's constructor slot,
// this is ignored by instanceof - only y's prototype's
// constructor slot is considered.

İşlevler, aşağıda gösterildiği gibi "statik özelliklere" (C++/Java terminolojisi kullanılarak) benzer bir etki üretmek için kullanılabilen nesnelerdir. (İşlev nesnesinin ayrıca aşağıdaki "Devralma" bölümünde tartışıldığı gibi özel bir prototip özelliği vardır.)

Komut dosyası altyapısı artık başvurulmayan nesneleri çöpe atacağından, nesne silme işlemi nadiren kullanılır .

Miras

JavaScript, Self tarzında prototipleme yoluyla kalıtım hiyerarşilerini destekler .

Aşağıdaki örnekte, Derived sınıfı, Base sınıfından miras alır . Tüm d olarak oluşturulur türetilmiş , taban örneğine referans Base kopyalanır d.base .

Derive için bir değer içermeyen aBaseFunction bu alınır, böylece aBaseFunction zaman aBaseFunction erişilir . Bu, d.aBaseFunction değerine yansıtılan base.aBaseFunction değeri değiştirilerek netleştirilir .

Bazı uygulamalar, prototipe aşağıda gösterildiği gibi __proto__ yuvası kullanılarak erişilmesine veya açıkça ayarlanmasına izin verir .

function Base() {
  this.anOverride = function() { console.log("Base::anOverride()"); };

  this.aBaseFunction = function() { console.log("Base::aBaseFunction()"); };
}

function Derived() {
  this.anOverride = function() { console.log("Derived::anOverride()"); };
}

base = new Base();
Derived.prototype = base; // Must be before new Derived()
Derived.prototype.constructor = Derived; // Required to make `instanceof` work

d = new Derived();    // Copies Derived.prototype to d instance's hidden prototype slot.
d instanceof Derived; // true
d instanceof Base;    // true

base.aBaseFunction = function() { console.log("Base::aNEWBaseFunction()"); }

d.anOverride();    // Derived::anOverride()
d.aBaseFunction(); // Base::aNEWBaseFunction()
console.log(d.aBaseFunction == Derived.prototype.aBaseFunction); // true

console.log(d.__proto__ == base); // true in Mozilla-based implementations and false in many others.

Aşağıda, örnek oluşturma sırasında prototiplere yapılan referansların nasıl kopyalandığı açıkça gösterilmektedir , ancak bir prototipte yapılan bu değişiklikler, ona başvuran tüm örnekleri etkileyebilir.

function m1() { return "One"; }
function m2() { return "Two"; }
function m3() { return "Three"; }

function Base() {}

Base.prototype.m = m2;
bar = new Base();
console.log("bar.m " + bar.m()); // bar.m Two

function Top() { this.m = m3; }
t = new Top();

foo = new Base();
Base.prototype = t;
// No effect on foo, the *reference* to t is copied.
console.log("foo.m " + foo.m()); // foo.m Two

baz = new Base();
console.log("baz.m " + baz.m()); // baz.m Three

t.m = m1; // Does affect baz, and any other derived classes.
console.log("baz.m1 " + baz.m()); // baz.m1 One

Uygulamada bu temaların birçok varyasyonu kullanılır ve hem güçlü hem de kafa karıştırıcı olabilir.

İstisna işleme

JavaScript, çalışma zamanı hatalarını işlemek için bir try ... catch ... finally istisna işleme ifadesi içerir .

try ... catch ... finallyDeyim yakalar istisnalar bir hata veya atmak deyimi kaynaklanan. Sözdizimi aşağıdaki gibidir:

try {
  // Statements in which exceptions might be thrown
} catch(errorValue) {
  // Statements that execute in the event of an exception
} finally {
  // Statements that execute afterward either way
}

Başlangıçta, try bloğu içindeki ifadeler yürütülür. Bir istisna atılırsa, betiğin kontrol akışı, hata argümanı olarak mevcut istisna ile derhal catch bloğundaki ifadelere aktarılır. Aksi takdirde yakalama bloğu atlanır. Belirli bir hatayı işlemek istemiyorsa, catch bloğu throw(errorValue) işlevini gerçekleştirebilir .

Her durumda nihayet bloğundaki ifadeler her zaman yürütülür. Bu, kaynakları boşaltmak için kullanılabilir, ancak bellek otomatik olarak çöp toplanır.

Ya yakalama ya da nihayet maddesi atlanabilir. Yakalama bağımsız değişkeni gereklidir.

Mozilla uygulaması, ECMAScript standardının bir uzantısı olarak birden çok yakalama ifadesine izin verir. Java'da kullanılana benzer bir sözdizimi izlerler :

try { statement; }
catch (e if e == "InvalidNameException")  { statement; }
catch (e if e == "InvalidIdException")    { statement; }
catch (e if e == "InvalidEmailException") { statement; }
catch (e)                                 { statement; }

Bir tarayıcıda, onerror olayı daha çok istisnaları yakalamak için kullanılır.

onerror = function (errorValue, url, lineNr) {...; return true;};

Yerel işlevler ve yöntemler

(Web tarayıcılarıyla ilgili değildir.)

değerlendirme (ifade)

İlk parametreyi, atama ifadeleri içerebilen bir ifade olarak değerlendirir. Fonksiyonlarda yerel değişkenlere ifade ile başvurulabilir. Ancak, evalkötü bir aktörün rastgele kod yürütmesine izin verdiği için büyük bir güvenlik riskini temsil eder, bu nedenle kullanımı önerilmez.

(function foo() {
  var x = 7;
  console.log("val " + eval("x + 2"));
})(); // shows val 9.

Ayrıca bakınız

• JavaScript tabanlı kaynak kodu düzenleyicilerinin karşılaştırılması
• JavaScript

Referanslar

daha fazla okuma

• Danny Goodman: JavaScript İncil , Wiley, John & Sons, ISBN  0-7645-3342-8 .
• David Flanagan, Paula Ferguson: JavaScript: Kesin Kılavuz , O'Reilly & Associates, ISBN  0-596-10199-6 .
• Thomas A. Powell, Fritz Schneider: JavaScript: Tam Referans , McGraw-Hill Companies, ISBN  0-07-219127-9 .
• Axel Rauschmayer: JavaScript Konuşma: Programcılar için Derinlemesine Kılavuz , 460 sayfa, O'Reilly Media, 25 Şubat 2014, ISBN  978-1449365035 . ( ücretsiz çevrimiçi sürüm )
• Emily Vander Veer: Aptallar İçin JavaScript, 4. Baskı , Wiley, ISBN  0-7645-7659-3 .

Dış bağlantılar

• JavaScript'e yeniden giriş - Mozilla Developer Center
• JavaScript Döngüleri
• ECMAScript standart referansları: ECMA-262
• Etkileşimli JavaScript Dersleri - örnek tabanlı
• About.com'da JavaScript: dersler ve açıklama
• JavaScript Eğitimi
• JavaScript sürümleri 1.5 , 1.4 , 1.3 ve 1.2 için Mozilla Developer Center Temel Referansları
• Mozilla JavaScript Dil Belgeleri