فصل 4ساختارهای داده: اشیاء و آرایه‌ها

در دو موقعیت از من پرسش شد، ‍'ببخشید، آقای بابیج اگر اعداد غلطی را به ماشین بدهی، ماشین پاسخ درست را خودش تولید می‌کند؟ ' [...] من نمی‌توانم به درستی درک کنم چه آشفتگی ذهنی می‌تواند اینچنین سوالی را برانگیزد.

اعداد، مقادیر بولی، و رشته‌ها عناصری هستند که ساختار داده‌ها از آن‌ها ساخته می‌شوند. اگرچه انواع زیادی از اطلاعات وجود دارند که نیاز به چیزی بیش از یک عنصر دارند. اشیاء این امکان را به ما می‌دهند که مقادیر مختلف – از جمله دیگر اشیاء – را با هم ترکیب کنیم و ساختار‌های پیچیده‌تری را بسازیم.

برنامه‌هایی که تا کنون ساخته‌ایم فقط با انواع داده‌ی ساده کار می‌کردند. در این فصل ساختار‌های داده‌ی پایه را معرفی می‌کنیم. در انتهای این فصل، به اندازه کافی اطلاعات در اختیار دارید که نوشتن برنامه‌های کاربردی را شروع کنید.

این فصل با مثال‌های برنامه‌نویسی کم و بیش واقعی جلو می‌رود تا مفاهیم جدید را همانطور که در مسئله پیش می‌آیند، معرفی کند. کد‌های مثال‌ها اغلب با توابع و متغیر‌هایی که پیش‌تر معرفی شده‌اند ساخته می‌شوند.

انسان‌سنجاب

هر از چند گاهی معمولا بین ساعت هشت تا ده شب ژاک متوجه می‌شود که تغییر شکل داده و به یک جونده کوچک با دمی پرپشت تبدیل می‌شود.

از طرفی، ژاک نسبتا خوشحال است که شبیه به داستان‌های کلاسیک، تبدیل به گرگ نمی‌شود. سنجاب شدن احتمالا مشکلات کمتری نسبت به گرگ شدن ایجاد می‌کند. به جای اینکه نگران باشد که اتفاقی همسایه‌اش را نخورد (که خیلی ناجور است)، نگران خورده شدن توسط گربه‌ی همسایه است. بعد از دو مرتبه‌ای که روی شاخه‌ی باریک و لرزان بالای یک درخت بلوط، لخت و گیج، بیدار شد، در‌ها و پنجره‌های اتاقش را شب‌ها قفل می‌کرد و چندتایی گردو هم کف اتاق قرار می‌داد که سرگرم بماند.

این، مشکل گربه‌ی همسایه و درخت را حل می‌کرد. اما ژاک به دنبال این بود که از این مشکل به طور کلی ر‌هایی یابد. تبدیل شدن‌های بی‌نظم و قاعده باعث شده بود که شک کند شاید چیز خاصی علت این مشکل باشد. برای مدتی، فکر می‌کرد که این اتفاق در روز‌هایی رخ می‌دهد که نزدیک درخت بلوط بوده است. اما دوری از درخت بلوط هم کمکی نکرد و مشکل برطرف نشد.

ژاک با انتخاب روشی علمی‌تر، یک گزارش روزانه از همه‌ی فعالیت‌های یک روز و وضعیت تبدیل شدن به سنجاب را نگهداری می‌کند. با در دست داشتن این اطلاعات، او امیدوار است بتواند شرایطی که باعث می‌شود به سنجاب تبدیل شود را محدودتر کند.

اکنون اولین کاری که باید انجام دهد طراحی یک ساختار داده برای ذخیره این اطلاعات است.

مجموعه‌های داده

برای کار با داده‌های دیجیتال، ابتدا باید راهی برای ارائه‌ی آن‌ها در حافظه‌ی کامپیوتر (ماشین) بیابیم. به عنوان یک مثال ساده، فرض کنید که می‌خواهیم مجموعه ای از اعداد، 2، 3، 5، 7، و 11 را در حافظه قرار دهیم.

برای این کار می‌توانیم از رشته‌ها به شکلی خلاقانه استفاده کنیم – به هر حال رشته‌ها می‌توانند هر طولی داشته باشند؛ پس می‌توان داده‌های زیادی را در درون آن‌ها قرار داد – و از نمایش رشته‌ای"2 3 5 7 11" استفاده نماییم. اما این کار ایراد‌هایی نیز دارد. برای استفاده از اعداد، مجبور خواهید شد که به شکلی آن‌ها را از دل رشته‌ها استخراج و به نوع عدد تبدیل کنید.

خوشبختانه، جاوااسکریپت نوع داده‌ای فراهم می‌کند که به طور خاص برای ذخیره دنباله‌ای از مقدار‌ها استفاده می‌شود. این نوع داده‌ی خاص آرایه نام دارد و به این صورت نوشته می‌شود که مقدار‌ها بین براکت قرار می‌گیرند و با ویرگول جدا می‌شوند.

let listOfNumbers = [2, 3, 5, 7, 11];
console.log(listOfNumbers[2]);
// → 5
console.log(listOfNumbers[0]);
// → 2
console.log(listOfNumbers[2 - 1]);
// → 3

برای دستیابی به عناصر درون یک آرایه نیز، از براکت‌ها استفاده می‌شود. یک جفت براکت که بلافاصله بعد از یک عبارت می‌آید و بعد از آن عبارتی دیگر درون آن قرار می‌گیرد. با این کار عنصر مورد نظرمان را با استفاده از شاخصی که به وسیله عبارت داخل براکت‌ها مشخص می‌کنیم، در داخل عبارت سمت چپ جستجو می‌کنیم.

اولین خانه‌ی یک آرایه، صفر است، نه یک. بنابراین اولین عنصر را می‌توان با listOfNumbers[0] بدست آورد. شمارش از صفر، در تکنولوژی سابقه‌ای دیرینه دارد و در بعضی مواقع، کاری بسیار منطقی می‌باشد؛ اما ممکن است کمی زمان ببرد تا به آن عادت کنید. می‌توانید شاخص یا اندیس آرایه را به صورت تعداد آیتم‌هایی که باید از ابتدای آرایه گذشت تا به عنصر مورد نظر رسید، تصور کنید.

خاصیت‌ها

در فصل‌های قبل، با عبارت‌هایی روبرو شدیم که ظاهری ناآشنا داشتند مانند myString.length (برای بدست آوردن طول رشته) یا Math.max (برای یافتن بیشینه‌ی اعداد). این‌ها عبارت‌هایی هستند که به خاصیتی از یک مقدار دسترسی دارند. در مثال اول، به خاصیت length از مقدار myString اشاره می‌کنیم. در مورد دوم، به خاصیتی با نام max از شیء Math دسترسی پیدا کرده‌ایم (که این شیء شامل مجموعه‌ای از ثابت‌ها و توابع ریاضی می‌باشد).

تقریبا همه‌ی مقدار‌های جاوااسکریپت دارای خاصیت‌هایی می‌باشند. مورد استثنا null و undefined است. اگر سعی کنید تا به خاصیتی از این دو اشاره کنید، با خطا مواجه خواهید شد.

null.length;
// → TypeError: null has no properties

دو روش رایج برای دسترسی به خاصیت‌ها در جاوااسکریپت استفاده از نقطه و براکت است. هر دو روش value.x و value[x] به خاصیتی از value اشاره می‌کنند – اما نه لزوما به خاصیتی یکسان. تفاوت به نحوه‌ی تفسیر x بر می‌گردد. زمانی که از نقطه استفاده می‌کنیم، قسمت بعد از نقطه، بایستی نام متغیری معتبر باشد که مستقیما نام خاصیت را مشخص می‌کند. اما زمانی که از براکت استفاده می‌شود، عبارتی که بین براکت‌ها قرار می‌گیرد ارزیابی شده تا نام خاصیت مشخص شود. در حالیکه value.x خاصیتی از value که نام آن “x” است را برمی‌گرداند، value[x] سعی می‌کند تا عبارت x را ارزیابی کرده و نتیجه‌ی آن را به عنوان نام خاصیت استفاده کند.

بنابراین اگر می‌دانید که نام خاصیت مورد نظرتان color است، به سراغ value.color بروید. اگر قصد دارید به خاصیتی اشاره کنید که نامش در متغیر i ذخیره شده است، می‌توانید از value[i] استفاده کنید. نام یک خاصیت می‌تواند هر رشته‌ای باشد، اما روش استفاده از نقطه، فقط روی نام‌هایی کار می‌کند که برای یک متغیر معتبر می‌باشند. بنابراین اگر قصد دارید تا به خاصیتی به نام 2 یا John Doe دسترسی داشته باشید، باید حتما از براکت‌ها استفاده کنید: value[2] یا value["John Doe"].

عناصر درون یک آرایه به عنوان خاصیت‌های آن ذخیره می‌شوند که برای نام این خاصیت‌ها از اعداد استفاده می‌شود. چون نمی‌توان از نقطه برای دسترسی به نام‌های عدد استفاده کرد، و اغلب لازم است تا به خانه‌های آرایه با استفاده از متغیر‌ها اشاره کنیم، باید از روش براکت برای دستیابی به آن‌ها استفاده نماییم.

خاصیت length در آرایه‌ها نیز تعداد عناصری که در آرایه وجود دارد را نشان می‌دهد. نام این خاصیت (length)، نامی معتبر برای یک متغیر می‌باشد و ما از آن آگاه بودیم پس به سراغ روش array.length می‌رویم چراکه از array["length"] آسان‌تر نوشته می‌شود.

متدها

هر دوی اشیاء رشته‌ای و آرایه‌ای، علاوه بر خاصیت length تعدادی خاصیت دیگر نیز دارند که حاوی مقدار‌هایی از جنس تابع می‌باشند.

let doh = "Doh";
console.log(typeof doh.toUpperCase);
// → function
console.log(doh.toUpperCase());
// → DOH

همه‌ی رشته‌ها خاصیت toUpperCase را دارند که در صورت فراخوانی، یک کپی از رشته را با حروف بزرگ برمی‌گرداند. همچنین toLowerCase نیز وجود دارد که عکس آن عمل می‌کند.

جالب آن‌که، وقتی که toUpperCase فراخوانی می‌شود علی رغم اینکه مقداری به عنوان آرگومان دریافت نمی‌کند، این تابع به نحوی به رشته‌ی "Doh" دسترسی دارد (مقداری که خاصیت را روی آن فراخوانی کرده‌ایم). چگونگی کارکرد این موضوع درفصل 6 توضیح داده می‌شود.

به خاصیت‌هایی که حاوی تابع می‌باشند معمولا متد (method) گفته می‌شود؛ متد‌های مربوط به مقداری که به آن تعلق دارند. همانطور که toUpperCase متدی از یک رشته محسوب می‌شود.

مثال پیش رو، دو متد را شرح می‌دهد که می‌توانید از آن‌ها برای دستکاری آرایه‌ها استفاده کنید:

let sequence = [1, 2, 3];
sequence.push(4);
sequence.push(5);
console.log(sequence);
// → [1, 2, 3, 4, 5]
console.log(sequence.pop());
// → 5
console.log(sequence);
// → [1, 2, 3, 4]

متد push را می‌توان برای افزودن مقدار‌ها به انتهای یک آرایه استفاده کرد. متد pop عکس آن عمل می‌کند: آخرین مقداری که در انتهای یک آرایه وجود دارد را حذف کرده و برمی‌گرداند.

نام این دو متد در کار‌های مرتبط با پشته‌ها از قدیم استفاده می‌شده است. یک پشته (stack)، در برنامه‌نویسی، ساختار داده‌ای است که این امکان را به شما می‌دهد تا مقادیر را به آن وارد کرده و به ترتیب عکس از آن خارج نمایید. بنابراین مقداری که آخر از همه وارد شده است، اول از همه خارج می‌شود. این کار‌ها در برنامه‌نویسی رایج هستند – ممکن است پشته‌ی فراخوانی توابع که در فصل قبل بحث شد را به خاطر بیاورید که نمونه‌ای از همین مفهوم است.

اشیاء (Objects)

برگردیم به مثال انسان‌سنجاب. می‌توان مجموعه‌ای از گزارش‌های روزانه را به صورت یک آرایه نشان داد. اما گزارش‌ها فقط شامل رشته یا عدد نمی‌باشند – هر گزارش باید فهرستی از فعالیت‌ها به همراه یک مقدار بولی که نشان می‌دهد ژاک به سنجاب تبدیل شده است یا خیر را ذخیره کند. در حالت ایده‌آل، دوست داشتیم که این اطلاعات را با هم گروه‌بندی کرده و یک مقدار بسازیم و آن مقادیر گروه‌بندی شده را در آرایه‌ای از گزارش‌ها ذخیره کنیم.

مقادیری که از نوع object هستند دارای مجموعه‌ای از خاصیت‌های دلخواه می‌باشند. یکی از روش‌های ایجاد یک شیء استفاده از کروشه‌ها به عنوان یک عبارت است.

let day1 = {
  squirrel: false,
  events: ["work", "touched tree", "pizza", "running"]
};
console.log(day1.squirrel);
// → false
console.log(day1.wolf);
// → undefined
day1.wolf = false;
console.log(day1.wolf);
// → false

درون کروشه‌ها، می‌توانیم لیستی از خاصیت‌ها را (که با ویرگول جدا می‌شوند) تعریف کنیم. هر خاصیت به وسیله‌ی یک نام، یک کاراکتر دونقطه در جلوی آن و یک عبارت که مقدار خاصیت را مشخص می‌کند تعریف می‌شود. زمانی که تعریف یک شیء به چند خط می‌کشد، استفاده از تورفتگی در کد‌ها خوانایی را افزایش می‌دهد. خاصیت‌هایی که نامشان نام معتبری برای یک متغیر محسوب نمی‌شوند یا اعداد، می‌بایست درون نقل قول قرار بگیرند.

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

معنای آن این است که کروشه‌ها در جاوااسکریپت دو معنای متفاوت دارند. در شروع یک دستور، نشانگر شروع یک بلاک از دستورات، و در دیگر مکان‌ها، نمایانگر تعریف یک شیء می‌باشند. خوشبختانه، به ندرت کاربردی برای شروع یک دستور با یک شیء درون کروشه‌ها پیدا می‌شود، بنابراین ابهام بین این دو، مسئله‌ای ایجاد نمی‌کند.

اقدام به خواندن خاصیتی که وجود ندارد باعث تولید مقدار undefined می‌شود.

می‌توان مقداری را به یک خاصیت به وسیله‌ی عملگر = اختصاص داد. این کار باعث می‌شود که مقدار خاصیت مورد نظر – در صورت وجود – جایگزین شده یا در غیر این صورت یک خاصیت جدید در شیء به وجود بیاید.

استعاره‌ی بازوچه که برای متغیر‌ها استفاده می‌شد در اینجا نیز کاربرد دارد. خاصیت‌ها به مقدار‌ها دسترسی دارند و این مقدار‌ها ممکن است توسط دیگر متغیر‌ها و خاصیت‌ها نیز نگه داری شوند. می‌توانید اشیاء را اختاپوسی در نظر بگیرید که بازو‌های متعددی دارد که هر کدام از آن‌ها دارای نامی است که روی آن نوشته شده است.

عملگر delete باعث قطع یک بازوچه از این اختاپوس می‌شود. این عملگر، یکانی است و اگر به خاصیتی اعمال شود، خاصیت نام‌برده را از شیء حذف می‌کند. استفاده از این عملگر زیاد رایج نیست، اما به هر حال قابل استفاده است.

let anObject = {left: 1, right: 2};
console.log(anObject.left);
// → 1
delete anObject.left;
console.log(anObject.left);
// → undefined
console.log("left" in anObject);
// → false
console.log("right" in anObject);
// → true

عملگر دودویی in اگر به یک رشته یا شیء اعمال شود، مقداری از جنس بولی برمی‌گرداند که مشخص می‌کند که آن شیء دارای آن خاصیت می‌باشد یا خیر. تفاوت بین اختصاص undefined به یک خاصیت و حذف آن این است که در مورد اول، شیء مورد بحث همچنان آن خاصیت را دارد (اگرچه مقدار به درد بخوری ندارد) در حالیکه در مورد دوم خاصیت دیگر وجود ندارد و عملگر in مقدار false را برمی‌گرداند.

برای بدست آوردن خاصیت‌های یک شیء، می‌توانید از تابع Object.keys استفاده کنید. اگر شیئی را به آن بدهید، آرایه‌ای از نام خاصیت‌های شیء را دریافت می‌کنید.

console.log(Object.keys({x: 0, y: 0, z: 2}));
// → ["x", "y", "z"]

تابع دیگری به نام Object.assign نیز وجود دارد که تمام خاصیت‌های یک شیء را در شیء دیگری کپی می‌کند.

let objectA = {a: 1, b: 2};
Object.assign(objectA, {b: 3, c: 4});
console.log(objectA);
// → {a: 1, b: 3, c: 4}

آرایه‌ها نیز، در واقع شکل خاصی از اشیاء هستند که برای ذخیره‌ی دنباله‌ای از چیز‌ها اختصاصی شده‌اند. اگر typeof [] را ارزیابی کنید، مقدار "object" تولید می‌شود. می‌توانید آن‌ها را به عنوان اختاپوس‌های درازی در نظر بگیرید که همه‌ی بازو‌های آن‌ها به شکل ردیفی مرتب به وسیله‌ی اعداد برچسب‌گذاری شده‌اند.

بنابراین می‌توانیم دفترچه‌ی ژاک را به صورت آرایه‌ای از اشیاء نمایش دهیم.

let journal = [
  {events: ["work", "touched tree", "pizza",
            "running", "television"],
   squirrel: false},
  {events: ["work", "ice cream", "cauliflower",
            "lasagna", "touched tree", "brushed teeth"],
   squirrel: false},
  {events: ["weekend", "cycling", "break", "peanuts",
            "beer"],
   squirrel: true},
  /* and so on... */
];

تغییرپذیری

به زودی به برنامه‌نویسی واقعی می‌رسیم. قبل از آن، یک قسمت تئوری دیگر وجود دارد که باید درک شود.

تا حالا متوجه شده‌ایم که مقدار اشیاء را می‌توان تغییر داد. انواع مقدار‌هایی که در فصل‌های پیشین بحث کردیم، مانند اعداد، رشته‌ها و مقادیر بولی، همه غیرقابل تغییر بودند. تغییر مقداری از این انواع داده غیر ممکن است. می‌توانید آن‌ها را ترکیب کنید تا مقادیر جدیدی ایجاد کنید اما اگر مقدار رشته‌ای خاصی را بگیرید، مقدارش همیشه همان خواهد ماند. متن داخلش را نمی‌توان عوض کرد. اگر رشته‌ای داشته باشید که مقدار "cat" را دربردارد، برای کد‌های برنامه امکان ندارد که بتوانند یک کاراکتر از آن را تغییر دهند و مثلا به "rat" تبدیلش کنند.

محتوای یک مقدار از نوع شیء را می‌توان به وسیله‌ی خاصیت‌هایش تغییر داد. این کار باعث می‌شود که یک شیء در زمان‌های مختلف محتوای متفاوتی داشته باشد.

زمانی که دو عدد مثلا 120 و 120 را داریم، می‌توانیم هر دو را دقیقا یک عدد مشابه در نظر بگیریم، فارغ از اینکه به بیت‌های فیزیکی یکسانی مربوط باشند یا خیر. اما در اشیاء، بین داشتن دو ارجاع به یک شیء یکسان و داشتن دو شیء متفاوت که خاصیت‌های مشابهی دارند، تفاوت وجود دارد. به کد‌های زیر رو توجه کنید:

let object1 = {value: 10};
let object2 = object1;
let object3 = {value: 10};

console.log(object1 == object2);
// → true
console.log(object1 == object3);
// → false

object1.value = 15;
console.log(object2.value);
// → 15
console.log(object3.value);
// → 10

متغیر‌های object1 و object2 به شیء مشابهی اشاره می‌کنند که به همین دلیل تغییر object1 منجر به تغییر مقدار object2 هم می‌شود. گفته می‌شود این دو هویت یکسانی دارند. متغیر object3 به شیء دیگری اشاره می‌کند که دارای خاصیت‌هایی مشابه object1 است اما در فضای متفاوتی قرار گرفته است.

متغیر‌ها نیز می‌توانند از نوع ثابت و غیر ثابت باشند، اما این قضیه ارتباطی به رفتار مقدار‌های آن‌ها ندارد. اگرچه مقداری از جنس عدد تغییر ناپذیر است، اما می‌توانید از یک متغیر که با let تعریف شده است استفاده کنید تا عددی که متغیر به آن اشاره می‌کند را عوض کنید. به طور مشابه، اگرچه یک ثابت که با const برای یک شیء تعریف شده است را نمی‌توان تغییر داد و همیشه به شیء مشابهی اشاره خواهد کرد، اما محتوای آن شیء قابل تغییر است.

const score = {visitors: 0, home: 0};
// This is okay
score.visitors = 1;
// This isn't allowed
score = {visitors: 1, home: 1};

عملگر == جاوااسکریپت، وقتی برای مقایسه‌ی اشیاء استفاده می‌شود، تنها زمانی مقدار true را برمی‌گرداند که هر دو شیء دقیقا مقدار یکسانی باشند. مقایسه‌ی اشیاء متفاوت حتی زمانی که محتوای آن‌ها یکسان باشد باعث برگرداندن false می‌شود. در جاوااسکریپت، عملگری برای مقایسه‌ی عمیق فراهم نشده است که بتواند محتوای اشیاء را بررسی و مقایسه کند. اما خودتان می‌توانید آن را بنویسید (یکی از تمرین‌های پایان این فصل همین مساله خواهد بود).

برنامه‌ی گزارش مسخ

خب ژاک برنامه‌ی مفسر جاوااسکریپت را اجرا می‌کند و محیطی که برای نوشتن گزارش روزانه نیاز دارد را فراهم می‌نماید.

let journal = [];

function addEntry(events, squirrel) {
  journal.push({events, squirrel});
}

توجه کنید که شیئی که به ژورنال اضافه می‌شود کمی غیر عادی به نظر می‌رسد. به جای اینکه خاصیت را به شکل events: events بنویسیم، فقط نام خاصیت نوشته شده است. این دستور کوتاه معادل همان روش معمولی است – اگر در روش تعریف شیء به وسیله کروشه‌ها، نام خاصیتی بدون تعریف مقدارش نوشته شود، مقدار آن از متغیری با همان نام گرفته می‌شود.

بنابراین هر شب ساعت ده – یا گاهی اوقات صبح روز بعد، بعد از پایین آمدن از قفسه بالایی کتابخانه‌اش- ژاک گزارش آن روز را ثبت می‌کند.

addEntry(["work", "touched tree", "pizza", "running",
          "television"], false);
addEntry(["work", "ice cream", "cauliflower", "lasagna",
          "touched tree", "brushed teeth"], false);
addEntry(["weekend", "cycling", "break", "peanuts",
          "beer"], true);

زمانی که به مقدار کافی اطلاعات در دست باشد، او قصد دارد تا به محاسبه‌ی ارتباط بین تبدیل شدنش به سنجاب و اتفاقاتی که در آن روز افتاده است بپردازد و امیدوار است چیز‌های مفیدی از این همبستگی‌ها بدست بیاورد.

همبستگی مقیاسی برای تعیین میزان وابستگی بین متغیر‌های آماری است. یک متغیر آماری شبیه به متغیر‌ها در زبان‌های برنامه‌نویسی نیست. در آمار، شما معمولا مجموعه‌ای از سنجش‌ها را در اختیار دارید و هر متغیر با همه‌ی سنجش‌ها اندازه‌گیری می‌شود. همبستگی بین متغیر‌ها معمولا به شکل ضریبی بین -1 تا 1 ایجاد می‌شود. ضریب همبستگی صفر به معنای این است که دو متغیر هیچ ارتباطی با هم ندارند و ضریب همبستگی یک به معنای ارتباط کامل دو متغیر است – اگر یکی از آن‌ها را بدانید، دیگری را نیز می‌توانید بدست بیاورید. منفی یک (-1) نیز به معنای ارتباط کامل دو متغیر اما به شکل معکوس و مخالف است- زمانی که یکی درست است دیگری نادرست خواهد بود.

برای محاسبه‌ی اندازه‌ی ضریب همبستگی بین دو متغیر بولی، می‌توانیم از ضریب فی (ϕ) استفاده کنیم. این ضریب فرمولی است که ورودی آن یک جدول فراوانی از تعداد دفعاتی است که ترکیب‌های مختلف دو متغیر مشاهده شده‌اند. خروجی فرمول، عددی بین -1 و 1 است که میزان همبستگی را مشخص می‌کند.

می‌توانیم رخداد خوردن پیتزا را در نظر بگیریم و آن را در جدول فراوانی به شکل زیر قرار دهیم، جایی که هر عدد نمایانگر تعداد دفعاتی است که ترکیب مورد نظر ما اتفاق افتاده است:

اگر جدول را n بنامیم، می توان ϕ را با فرمول زیر محاسبه کرد:

(اگر دارید کتاب را می‌بندید تا به سراغ خاطرات وحشتناک کتاب ریاضی دبیرستان بروید، صبر کنید! قرار نیست که در این کتاب شما را با فرمول‌های عجیب و غریب اذیت کنم – فعلا همین یک فرمول کافی است. برای همین یک مورد هم تمام کاری که قرار است بکنیم تبدیل آن به جاوااسکریپت است.)

نماد n₀₁ نشان دهنده‌ی تعداد اندازه‌گیری‌هایی است که اولین متغیر (سنجاب شدن) برابر false یا 0 و دومین اندازه‌گیری (پیتزا خوردن) true (1) شده است. در این مثال n₀₁ برابر 9 است.

مقدار n_1• برابر با جمع همه‌ی اندازه‌گیری‌هایی است که متغیر اول آن ها true ارزیابی شده است که در این مثال 5 است. به همین صورت n_•0 به مجموع اندازه‌گیری‌هایی که متغیر دوم‌ آن‌ها false است اشاره می‌کند.

بنابراین برای جدول پیتزا، بالای کسر یا صورت کسر می شود 1×76−4×9 = 40 و مخرج کسر برابر است با ریشه‌ی دوم 5×85×10×80 یا √340000٫ که حاصل می شود ϕ ≈ 0.069 که عدد خیلی کوچکی است. خوردن پیتزا به نظر می‌رسد تاثیری در تبدیل ژاک به سنجاب ندارد.

محاسبه‌ی ضریب همبستگی

در جاوااسکریپت می‌توانیم یک جدول دو-در-دو را با یک آرایه‌ی چهار-عنصری نشان دهیم: [76, 9, 4, 1]. می‌توان به شکل‌های دیگر نیز این کار را انجام داد مثل استفاده از آرایه‌ای که از دو آرایه‌ی دو خانه‌ای تشکیل شده است ([[76, 9], [4, 1]]) یا شیئی با خاصیت‌هایی به شکل "11" و "01"، اما استفاده از یک آرایه‌ی تخت ساده‌تر است و باعث می‌شود که عبارت‌هایی که برای دسترسی به خانه‌های آرایه می‌نویسیم کوتاهتر شوند. خانه‌های آرایه را به عنوان دو بیت دودویی محسوب می‌کنیم که رقم چپ (با ارزش‌ترین عدد) نمایانگر متغیر سنجاب‌شدن و رقم راست (کم ارزش‌ترین) معرف متغیر رخداد است. به عنوان مثال عدد دودویی 10 به موردی اشاره می‌کند که ژاک به سنجاب تبدیل شده است اما رخداد مورد نظر (مثلا خوردن پیتزا) رخ نداده است. این کار چهار مرتبه اتفاق افتاده است و به علت اینکه عدد دودویی 10 در سیستم دهدهی معادل 2 می‌باشد، ما این عدد را در خانه‌ی 2 آرایه ذخیره خواهیم کرد.

تابع زیر محاسبه‌ی مقدار ϕ را از آرایه‌ی مذکور انجام می‌دهد:

function phi(table) {
  return (table[3] * table[0] - table[2] * table[1]) /
    Math.sqrt((table[2] + table[3]) *
              (table[0] + table[1]) *
              (table[1] + table[3]) *
              (table[0] + table[2]));
}

console.log(phi([76, 9, 4, 1]));
// → 0.068599434

کد بالا در واقع ترجمه‌ی مستقیم فرمول محاسبه ϕ به زبان جاوااسکریپت است. تابع Math.sqrt ریشه‌ی دوم عدد را حساب می‌کند که توسط شیء Math در محیط استاندارد جاوااسکریپت فراهم شده است. برای دستیابی به فیلد‌هایی شبیه به n_1• بایستی دو فیلد از جدول را با هم جمع کنیم چرا که مجموع ردیف‌ها یا ستون‌ها به شکل مستقیم در ساختار داده‌ی ما ذخیره نمی‌شوند.

ژاک به ثبت روزانه‌ی خود تا سه ماه ادامه داد. مجموعه داده‌های بدست آمده را می توانید در قسمت کدهای این فصل بدست بیاورید. این داده‌ها در متغیر JOURNAL ذخیره شده‌اند که فایل آن قابل بارگیری است.

برای استخراج یک جدول دو-در-دو برای یک رخداد خاص از دفتر روزانه، بایستی تمامی رکورد‌ها را پیمایش کنیم و تعداد دفعاتی که آن رخداد در ارتباط با سنجاب شدن اتفاق افتاده است را بشماریم.

function tableFor(event, journal) {
  let table = [0, 0, 0, 0];
  for (let i = 0; i < journal.length; i++) {
    let entry = journal[i], index = 0;
    if (entry.events.includes(event)) index += 1;
    if (entry.squirrel) index += 2;
    table[index] += 1;
  }
  return table;
}

console.log(tableFor("pizza", JOURNAL));
// → [76, 9, 4, 1]

آرایه‌ها متدی به نام includes دارند که وجود یک مقدار داده شده را در آرایه بررسی می‌کند. تابع بالا از این متد برای بررسی وجود نام رخداد مورد نظر در لیست رخداد‌ها برای یک روز مشخص استفاده می‌کند.

بدنه‌ی حلقه‌ی تابع tableFor مشخص می‌کند که هر کدام از مدخل‌های دفتر روزانه در کدام قسمت از جدول قرار می‌گیرند. این‌کار با بررسی وجود رخداد مورد نظر در مدخل و اینکه رخداد همزمان با سنجاب شدن اتفاق می‌افتد یا خیر، صورت می‌گیرد. سپس حلقه یک واحد به خانه‌ی مورد نظر در جدول اضافه می‌کند.

هم اکنون ما ابزاری را در اختیار داریم که برای محاسبه همبستگی‌ها نیاز داشتیم. تنها گامی که مانده این است که ضریب همبستگی را برای همه‌ی رخداد‌های ضبط شده پیدا کنیم و اینکه ببینیم کدام رخداد موثر بوده است.

حلقه‌ها در آرایه

در تابع tableFor حلقه‌ای وجود داشت که شبیه کد زیر بود:

for (let i = 0; i < JOURNAL.length; i++) {
  let entry = JOURNAL[i];
  // Do something with entry
}

این شکل از حلقه در جاوااسکریپت کلاسیک رایج است – که در آن هر بار سراغ یک خانه از آرایه می‌رویم که برای انجام آن از شمارنده‌ای متناسب با طول آرایه استفاده می‌کنیم تا بتوانیم به هر عنصر دسترسی داشته باشیم.

راه ساده‌تری در جاوااسکریپت مدرن برای این گونه حلقه‌ها وجود دارد.

for (let entry of JOURNAL) {
  console.log(`${entry.events.length} events.`);
}

زمانی که یک حلقه‌ی for به این شکل نوشته می‌شود که بعد از تعریف یک متغیر، کلیدواژه‌ی of نوشته می‌شود، مقداری که بعد از of می‌آید را پیمایش می‌کند. این حلقه نه تنها برای آرایه‌ها کاربرد دارد بلکه برای رشته‌ها و بعضی از دیگر ساختار‌های داده نیز استفاده می‌شود. با نحوه‌ی عملکر آن در فصل 6 آشنا می‌شویم.

تحلیل نهایی

لازم است تا محاسبه‌ی ضریب همبستگی را برای همه‌ی رخداد‌هایی که در مجموعه‌ی داده‌ها وجود دارد انجام دهیم. برای این کار، ابتدا باید همه‌ی انواع رخداد‌ها را پیدا کنیم.

function journalEvents(journal) {
  let events = [];
  for (let entry of journal) {
    for (let event of entry.events) {
      if (!events.includes(event)) {
        events.push(event);
      }
    }
  }
  return events;
}

console.log(journalEvents(JOURNAL));
// → ["carrot", "exercise", "weekend", "bread", …]

با پیمایش تک تک رخداد‌ها و افزودن آن‌هایی که قبلا در آرایه‌ی events موجود نبودند، این تابع تمامی رخداد‌ها را جمع‌آوری می‌کند.

با استفاده از آن می‌توانیم همه‌ی همبستگی‌ها را ببینیم.

for (let event of journalEvents(JOURNAL)) {
  console.log(event + ":", phi(tableFor(event, JOURNAL)));
}
// → carrot:   0.0140970969
// → exercise: 0.0685994341
// → weekend:  0.1371988681
// → bread:   -0.0757554019
// → pudding: -0.0648203724
// and so on...

به نظر می‌رسد که بیشتر ضرایب همبستگی به صفر نزدیک‌اند. خوردن هویج، نان، یا دسر، ظاهرا ارتباطی با سنجاب شدن ژاک ندارند. به نظر می‌رسد این تبدیل بیشتر در آخر هفته‌ها رخ می‌دهد. اجازه بدهید تا نتایج را کمی پالایش کنیم تا فقط نتایجی نشان داده شوند که ضریب همبستگی آن‌ها بیش از 0.1‌ و کمتر از -0.1 باشد.

for (let event of journalEvents(JOURNAL)) {
  let correlation = phi(tableFor(event, JOURNAL));
  if (correlation > 0.1 || correlation < -0.1) {
    console.log(event + ":", correlation);
  }
}
// → weekend:        0.1371988681
// → brushed teeth: -0.3805211953
// → candy:          0.1296407447
// → work:          -0.1371988681
// → spaghetti:      0.2425356250
// → reading:        0.1106828054
// → peanuts:        0.5902679812

آ‌ها! دو فاکتور در بین نتایج وجود دارد که ضریب آن‌ها مشخصا قوی‌تر از دیگر موارد است. خوردن بادام زمینی اثر مثبت زیادی در شانس تبدیل شدن به سنجاب دارد، در حالیکه مسواک زدن اثری قابل توجه اما در جهت معکوس ایجاد می‌کند.

جالب است. بیایید تا چیزی را آزمایش کنیم.

for (let entry of JOURNAL) {
  if (entry.events.includes("peanuts") &&
     !entry.events.includes("brushed teeth")) {
    entry.events.push("peanut teeth");
  }
}
console.log(phi(tableFor("peanut teeth", JOURNAL)));
// → 1

نتیجه‌ی قابل توجه‌ای است. تبدیل دقیقا زمانی رخ می‌دهد که ژاک بادام زمینی می‌خورد و فراموش می‌کند تا مسواک کند. اگر او آن قدر بی‌توجه به بهداشت دهان و دندان نبود، هرگز به این رنج دچار نمی‌شد.

با دانستن این، ژاک دیگر بادام زمینی نمی‌خورد و متوجه می‌شود که تبدیل دیگر اتفاق نمی‌افتد.

تا چند سال، اوضاع برای ژاک خیلی خوب پیش می‌رود. تا این که روزی کارش را از دست می‌دهد. چون ژاک در کشوری زندگی می‌کند که نداشتن کار به معنای نداشتن خدمات بهداشت و سلامت است، مجبور می‌شود تا در یک سیرک مشغول به کار شود جایی که نقشش مرد سنجابی شگفت‌انگیز است. او قبل از هر نمایش دهانش را پر از کره بادام زمینی می‌کند.

یک روز، ژاک خسته از این زندگی رقت‌انگیز، وقتی نتوانست دیگر به شکل انسانی خودش برگردد، لابلای یکی از شکاف‌های چادر سیرک می‌پرد و در جنگل ناپدید می‌شود. بعد از آن ژاک هرگز دیگر دیده نشد.

کمی آرایه‌شناسی بیشتر

قبل از تمام کردن این فصل، قصد دارم تا شما را با چند مفهوم دیگر مرتبط با اشیاء آشنا کنم. ابتدا با چند متد عمومی و مفید از آرایه‌ها آشنا می‌شویم.

pop و push را پیش‌تر در همین فصل دیدیم، که برای حذف و اضافه‌ی عناصر در انتهای آرایه استفاده می‌شدند. متد‌های مرتبط دیگری که همین کار را در ابتدای آرایه انجام می‌دهند shift و unshift می‌باشند.

let todoList = [];
function remember(task) {
  todoList.push(task);
}
function getTask() {
  return todoList.shift();
}
function rememberUrgently(task) {
  todoList.unshift(task);
}

کار برنامه‌ی بالا مدیریت یک صف وظایف است. برای افزودن یک وظیفه به انتهای صف، تابع remember("groceries") را فراخوانی می‌کنید و زمانی که برای انجام یک وظیفه آماده هستید، تابع getTask() را برای گرفتن (و حذف) یک وظیفه از جلوی صف فراخوانی می‌کنید. تابع rememberUrgently نیز برای افزودن یک وظیفه استفاده می‌شود اما آن را به جلوی صف اضافه می‌کند نه انتهای صف.

برای جستجوی یک مقدار خاص، آرایه‌ها متدی به نام indexOf را فراهم می‌کنند. این متد در طول آرایه از شروع تا پایان حرکت کرده و اندیسی که در آن، مقدار مورد درخواست پیدا شد – یا -1 در صورت پیدا نکردن – را برمی‌گرداند. برای جستجو از آخر به اول، متدی مشابهی وجود دارد که lastIndexOf نامیده می‌شود.

console.log([1, 2, 3, 2, 1].indexOf(2));
// → 1
console.log([1, 2, 3, 2, 1].lastIndexOf(2));
// → 3

هر دوی indexOf و lastIndexOf آرگومان اختیاری دیگری قبول می‌کنند که برای مشخص کردن نقطه‌ی شروع جستجو استفاده می‌شود.

یکی دیگر از متد‌های اساسی آرایه‌ها، متد slice است که شماره‌ی اندیس‌های شروع و پایان را گرفته و آرایه‌ای که شامل عناصر بین آن‌ها می‌شود را تولید می‌کند. این آرایه تولیدی شامل عنصر آغازین و فاقد عنصر پایانی خواهد بود.

console.log([0, 1, 2, 3, 4].slice(2, 4));
// → [2, 3]
console.log([0, 1, 2, 3, 4].slice(2));
// → [2, 3, 4]

زمانی که اندیس پایانی به متد داده نشود، slice تمامی عناصری که بعد از اندیس آغازین قرار می‌گیرند را برمی‌گرداند. می‌توانید همچنین اندیس اول را هم مشخص نکنید که باعث می‌شود کل آرایه کپی شود.

متد concat برای چسباندن آرایه‌ها به هم و ساخت یک آرایه جدید استفاده می‌شود، شبیه کاری که عملگر + برای رشته‌ها انجام می‌دهد.

مثال پیش رو نحوه‌ی عملکرد هر دوی متد‌های slice و concat را نشان می‌دهد. تابع مثال، یک آرایه و یک اندیس را به عنوان ورودی دریافت می‌کند و آرایه‌ی جدیدی را برمی‌گرداند که برابر است با نسخه‌ای از آرایه‌ی دریافتی بدون عنصری که اندیسش داده شده است.

function remove(array, index) {
  return array.slice(0, index)
    .concat(array.slice(index + 1));
}
console.log(remove(["a", "b", "c", "d", "e"], 2));
// → ["a", "b", "d", "e"]

اگر به متد concat آرگومانی غیرآرایه‌ای بفرستید، این مقدار به عنوان یک آرایه‌ی تک عنصری محسوب می‌شود و به انتهای آرایه‌ی جدید اضافه خواهد شد.

رشته‌ها و خاصیت‌هایشان

می‌توانیم خاصیت‌هایی مثل length و toUpperCase را از مقدار‌های رشته‌ای فراخوانی کنیم. اما اگر سعی کنید خاصیت جدید به آن‌ها اضافه کنید، نتیجه‌ای نخواهد داشت.

let kim = "Kim";
kim.age = 88;
console.log(kim.age);
// → undefined

مقادیر نوع رشته، عدد و بولی، شیء محسوب نمی‌شوند. درست است که اگر سعی کنید خاصیت جدیدی روی آن تعریف کنید، مفسر جاوااسکریپت خطایی تولید نمی‌کند، اما این خاصیت‌ها را هم ایجاد و ذخیره نمی‌کند. همانطور که پیش‌تر گفته شد، این گونه مقادیر قابل تغییر نیستند.

اما این انواع داده، دارای خاصیت‌هایی از پیش تعریف شده می‌باشند. هر مقدار رشته‌ای حاوی چند متد است. slice و indexOf از متد‌های بسیار کاربردی رشته‌ها می‌باشند که به متد‌هایی با همین نام‌ها در آرایه‌ها، شباهت دارند.

console.log("coconuts".slice(4, 7));
// → nut
console.log("coconut".indexOf("u"));
// → 5

یک تفاوت indexOf رشته نسبت به آرایه، توانایی جستجوی رشته‌ای است که شامل بیش از یک کاراکتر می‌باشد در حالی که در متد مربوط به آرایه، فقط جستجو را روی عناصر تکی انجام می‌دهد.

console.log("one two three".indexOf("ee"));
// → 11

متد trim فضای خالی ( شامل فضای خالی، کاراکتر خط جدید، کاراکتر تب، و کاراکتر‌های مشابه) را از آغاز و پایان رشته حذف می‌کند.

console.log("  okay \n ".trim());
// → okay

تابع zeroPad که در فصل قبل نوشتیم نیز به عنوان یک متد وجود دارد. اسم این متد padStart است و طول دلخواه و کاراکتر ترازبندی را به عنوان آرگومان می‌گیرد.

console.log(String(6).padStart(3, "0"));
// → 006

می‌توانید با استفاده از متد split یک رشته را بر اساس تکرار رشته‌ای دیگر تقسیم و جدا کنید و با استفاده از متد join دوباره به هم بچسبانید.

let sentence = "Secretarybirds specialize in stomping";
let words = sentence.split(" ");
console.log(words);
// → ["Secretarybirds", "specialize", "in", "stomping"]
console.log(words.join(". "));
// → Secretarybirds. specialize. in. stomping

یک رشته را می‌توان با استفاده از متد repeat تکرار کرد که در این صورت رشته‌ای جدید تولید می‌شود که حاوی کپی‌های متعدد از رشته‌ی اصلی می‌باشد که به هم چسبیده‌اند.

console.log("LA".repeat(3));
// → LALALA

پیش از این، با خاصیت length برای نوع رشته آشنا شدیم. دستیابی به کاراکتر‌های یک رشته شبیه دستیابی به عناصر یک آرایه است ( با در نظر گرفتن یک نکته که در فصل 5 به آن می‌پردازیم).

let string = "abc";
console.log(string.length);
// → 3
console.log(string[1]);
// → b

پارامتر rest

امکان مفیدی است اگر یک تابع بتواند به تعداد دلخواه آرگومان دریافت کند. به عنوان مثال، Math.max بیشینه‌ی همه‌ی آرگومان‌هایی که به آن داده می‌شود را برمی‌گرداند.

برای نوشتن این گونه توابع، بایستی سه علامت نقطه قبل از آخرین پارامتر تابع قرار دهید، مانند مثال زیر:

function max(...numbers) {
  let result = -Infinity;
  for (let number of numbers) {
    if (number > result) result = number;
  }
  return result;
}
console.log(max(4, 1, 9, -2));
// → 9

زمانی که تابعی با این تعریف فراخوانی می‌شود، پارامتری که با نماد سه‌نقطه‌ای آمده است، پارامتر rest، به یک آرایه اشاره می‌کند که حاوی تمامی دیگر آرگومان‌ها می‌باشد. اگر پارامتر‌های دیگری قبل از آن وجود داشته باشند، مقدار آن‌ها در آن آرایه قرار نمی‌گیرد. در حالتی که، مانند متد max، اولین پارامتر به این صورت تعریف شود، تمامی آرگومان‌ها را در بر خواهد گرفت.

با استفاده از این نماد سه نقطه‌ای، می‌توانید یک تابع را با آرایه‌ای از آرگومان‌ها فراخوانی کنید.

let numbers = [5, 1, 7];
console.log(max(...numbers));
// → 7

این کار باعث می‌شود که آرایه‌ی مورد نظر در فراخوانی تابع پخش بشود، به طوری که عناصرش به عنوان آرگومان‌های جدا محسوب شوند. همچنین می‌توان آرایه‌ی مشابهی را لابلای دیگر آرگومان‌ها ارسال کرد مثل: max(9, ...numbers, 2).

به طور مشابه، براکت‌های آرایه این امکان را به شما می‌دهند که از عملگر سه‌نقطه برای پخش آرایه‌ای دیگر در یک آرایه‌ی جدید استفاده کنید:

let words = ["never", "fully"];
console.log(["will", ...words, "understand"]);
// → ["will", "never", "fully", "understand"]

شیء Math

همانطور که دیده‌ایم، Math حاوی تعدادی تابع کاربردی مرتبط با اعداد است، مثل Math.max (بیشینه)، Math.min (کمینه)، و Math.sqrt (ریشه دوم عدد).

شیء Math به عنوان یک ظرف برای گروه‌بندی قابلیت‌های مرتبط استفاده می‌شود. تنها یک شیء Math وجود دارد، و تقریبا هرگز کاربردی به عنوان یک مقدار ندارد. در عوض، فضای نامی (namespace) را فراهم می‌کند که باعث می‌شود نیازی نباشد این متد‌ها و مقدار‌ها در فضای سراسری تعریف شوند.

داشتن متغیر‌های سراسری زیاد، به نوعی موجب آلودگی فضای نام (namespace)می‌شود. هرچه نام‌های بیشتری اشغال شوند، احتمال بیشتری برای جایگزینی ناخواسته و تصادفی مقدار متغیر‌ها وجود دارد. به عنوان مثال، بعید نیست که بخواهید چیزی را به نام max در یکی از برنامه‌هایتان تعریف کنید. اما به دلیل اینکه تابع از پیش تعریف شده‌ی max در جاوااسکریپت به شکل امنی درون شیء Math نگه داری می‌شود، نیازی نیست نگران تغییر تصادفی آن باشیم.

خیلی از زبان‌های برنامه‌نویسی، مانع از تعریف متغیری می‌شوند که قبلا تعریف شده است یا حداقل به شما در این صورت اخطار می‌دهند. جاوااسکریپت این کار را برای متغیر‌هایی که با let یا const تعریف شده‌اند انجام می‌دهد اما عجیب اینکه برای متغیر‌هایی که با var، توابعی که با function تعریف شده‌اند و متغیر‌های استاندارد زبان، حرکتی بروز نمی‌دهد.

برگردیم به شیء Math. اگر نیاز به محاسبات مثلثاتی دارید، Math می‌تواند به شما کمک کند. مانند متد‌های cos (کسینوس)، sin (سینوس)، و tan (تانژانت) به همراه توابع معکوس آن‌ها، acos، asin و atan. عدد π (پی) – در واقع نزدیک‌ترین تقریبی که برای آن در جاوااسکریپت وجود دارد – نیز به صورت Math.PI در دسترس است. یک سنت قدیمی در برنامه‌نویسی وجود دارد که نام ثابت‌ها را با حروف بزرگ می‌نویسند.

function randomPointOnCircle(radius) {
  let angle = Math.random() * 2 * Math.PI;
  return {x: radius * Math.cos(angle),
          y: radius * Math.sin(angle)};
}
console.log(randomPointOnCircle(2));
// → {x: 0.3667, y: 1.966}

اگر با سینوس و کسینوس آشنا نیستنید، نگران نباشید. زمانی که به سراغ استفاده از آن‌ها خواهیم رفت،‌ در در فصل 14، آن‌ها را توضیح خواهم داد.

در مثال قبل، از Math.random استفاده شد. این تابع عددی تصادفی بین صفر (شامل خود صفر) و یک (غیر از خود یک) را با هر بار فراخوانی، تولید می‌کند.

console.log(Math.random());
// → 0.36993729369714856
console.log(Math.random());
// → 0.727367032552138
console.log(Math.random());
// → 0.40180766698904335

اگرچه کامپیوتر‌ها ماشین‌هایی قطعی محسوب می‌شوند – همیشه به ورودی یکسان، واکنش یکسانی بروز می‌دهند – اما می‌توان از آن‌ها خواست تا اعدادی را تولید کنند که ظاهرا تصادفی هستند. برای این کار، کامپیوتر بعضی مقادیر مخفی را در نظر می‌گیرد، و هر وقت که شما درخواست عدد تصادفی می‌کنید، محاسبات پیچیده‌ای را روی آن مقدار‌های مخفی انجام می‌دهد تا مقدار جدیدی بسازد. مقدار جدید را ذخیره کرده و عددی که از آن گرفته شده را به عنوان پاسخ برمی‌گرداند. با این روش، قادر است که اعداد جدیدی تولید کند که به سختی قابل پیش بینی‌اند طوری که به نظر تصادفی می‌آیند.

اگر به جای اعداد اعشاری، به یک عدد تصادفی کامل(صحیح) نیاز داریم، می‌توانیم از متد Math.floor (که عدد ورودی‌اش را به نزدیک‌ترین عدد کوچکتر کامل گرد می‌کند) برای نتیجه Math.random استفاده کنیم.

console.log(Math.floor(Math.random() * 10));
// → 2

ضرب عدد تصادفی در عدد 10 باعث می‌شود که عددی بزرگتر مساوی 0 و کوچکتر از 10 را تولید کنیم. به علت اینکه Math.floor به سمت پایین عدد را گرد می‌کند، این عبارت، عددی تصادفی بین 0 تا 9 را تولید می‌کند.

همچنین توابع دیگری وجود دارد مثل Math.ceil برای گرد کردن به سمت بالا (سقف)، Math.round تولید نزدیک‌ترین عدد صحیح و Math.abs برای بدست آوردن قدرمطلق عدد (اندازه مطلق عدد فارغ از علامت آن، اعداد منفی را منفی کرده و به اعداد مثبت کاری ندارد).

تجزیه کردن (destructring)

اجازه بدهید به تابع محاسبه phi (فی) برگردیم:

function phi(table) {
  return (table[3] * table[0] - table[2] * table[1]) /
    Math.sqrt((table[2] + table[3]) *
              (table[0] + table[1]) *
              (table[1] + table[3]) *
              (table[0] + table[2]));
}

یکی از دلایلی که این تابع خوانایی سختی دارد این است که متغیری داریم که به آرایه‌ی ما ارجاع می‌دهد، در حالیکه بهتر این بود که متغیر‌هایی برای اشاره به عناصر آرایه داشتیم، مثل، let n00 = table[0] و از این قبیل. خوشبختانه راه مختصری برای این کار در جاوااسکریپت تعبیه شده است.

function phi([n00, n01, n10, n11]) {
  return (n11 * n00 - n10 * n01) /
    Math.sqrt((n10 + n11) * (n00 + n01) *
              (n01 + n11) * (n00 + n10));
}

این روش برای متغیر‌هایی که با let، var یا const تعریف شده‌اند نیز کار می‌کند. اگر می‌دانید که مقدار مورد نظر، یک آرایه است، می‌توانید از براکت‌ها برای دسترسی به درون آن مقدار استفاده کرده و محتوایش را مورد ارجاع قرار دهید.

روش مشابهی برای اشیاء نیز وجود دارد، استفاده از کروشه به جای براکت‌.

let {name} = {name: "Faraji", age: 23};
console.log(name);
// → Faraji

توجه داشته باشید، اگر سعی کنید null یا undefined را تجزیه کنید، با خطا مواجه خواهید شد، درست شبیه اینکه بخواهید مستقیما به خاصیتی از این دو مقدار اشاره کنید.

JSON

به دلیل این واقعیت که خاصیت‌ها (properties)، فقط به مقدار‌های متناظرشان دسترسی دارند نه اینکه واقعا آن‌ها را نگهداری کنند، آرایه‌ها و اشیاء به صورت دنباله‌ای از بیت‌ها در حافظه‌ی کامپیوتر ذخیره می‌شوند که آدرس‌های محتوای مرتبطشان را نگهداری می‌کنند (مکان‌های حافظه). بنابراین یک آرایه که آرایه‌ای دیگر درون آن قرار گرفته حداقل از یک ناحیه‌ی حافظه برای آرایه‌ی درونی، و ناحیه‌ای دیگر برای آرایه‌ی بیرونی تشکیل شده است، که حاوی (علاوه بر چیز‌های دیگر) یک عدد دودویی است که نمایانگر موقعیت آرایه‌ی درونی می‌باشد.

اگر لازم است که داده‌ها را برای استفاده در آینده، در یک فایل ذخیره کنید، یا به کامپیوتر دیگری در شبکه ارسال کنید، باید به شکلی این آدرس‌های حافظه را تبدیل به توصیفاتی کنید که بتوان آن را ذخیره یا ارسال کرد. می‌توانستید تمام حافظه‌ی کامپیوتر را همراه با آدرس مقدار مورد نظر ارسال کنید، ظاهرا شدنی است، اما به نظر می‌رسد روش خیلی خوبی محسوب نمی‌شود.

کاری که می‌توانیم در این موقعیت بکنیم این است که داده‌ها را پشت سرهم ردیف کنیم (serialize). به این معنا که آن را به متنی تخت تبدیل کنیم. یکی از فرمت‌های محبوب سریال کردن داده‌ها JSON نامیده می‌شود ( که جی سن تلفظ می‌شود)، که مخفف نشانه‌گذاری شیء جاوااسکریپت است (‍javascript object notation). این روش به طور گسترده به عنوان روشی برای ذخیره‌ی داده‌ها و ارسال/دریافت آن‌ها در وب استفاده می‌شود، حتی در دیگر زبان‌های برنامه‌نویسی غیر ازجاوااسکریپت نیز معمول است.

JSON با کمی محدودیت، بسیار شبیه به روش جاوااسکریپت در نوشتن آرایه‌ها و اشیاء به نظر می‌رسد. نام خاصیت‌ها باید حتما با نقل قول جفتی احاطه شوند، و فقط عبارت‌های داده‌ای ساده قابل قبول هستند – متغیر‌ها، فراخوانی توابع، یا هرچیزی که شامل محاسبه‌ی عملی می‌باشد مجاز نیستند. توضیحات هم در JSON مجاز نیستند.

یک مدخل گزارش روزانه ممکن است شبیه به کد زیر باشد اگر به فرمت JSON نوشته شود:

{
  "squirrel": false,
  "events": ["work", "touched tree", "pizza", "running"]
}

جاوااسکریپت دو متد JSON.stringify و JSON.parse را در اختیار ما قرار داده است تا بتوانیم داده‌ها را به JSON تبدیل یا از آن استخراج کنیم. تابع اول یک مقدار جاوااسکریپتی را گرفته و به رشته‌ای با فرمت JSON تبدیل می‌کند. تابع دوم رشته‌ای با فرمت JSON را گرفته و آن را به مقداری که درون رشته تعبیه شده است تبدیل می‌کند.

let string = JSON.stringify({squirrel: false,
                             events: ["weekend"]});
console.log(string);
// → {"squirrel":false,"events":["weekend"]}
console.log(JSON.parse(string).events);
// → ["weekend"]

خلاصه

اشیاء و آرایه‌ها ( آرایه‌ها هم شکلی خاصی از اشیاء هستند) روش‌هایی فراهم می‌کنند که به وسیله‌ی آن‌ها، مقادیر متعددی را گروه‌بندی کرده و به عنوان یک مقدار در اختیار داشته باشیم. به لحاظ مفهومی، این کار ما را قادر می‌سازد به جای نگهداری چیز‌های متعدد با دست، آن‌ها را در سبدی قرار داده و با خودمان جابجا کنیم.

اکثر مقادیر در جاواسکریپت دارای مجموعه‌ای از خاصیت‌ها می‌باشند، مورد استثنا null و undefined است. می‌توان به خاصیت‌ها به صورت value.prop یا value["prop"] دسترسی داشت. در اشیاء، خاصیت‌ها نام‌گذاری می‌شوند و معمولا مجموعه‌ی ثابتی از آن‌ها را نگه داری می‌کنند. آرایه‌ها، از سویی دیگر، حاوی تعداد متنوعی از مقدار‌های معمولا یک جنس می‌باشند و از اعداد (با شروع از صفر) به عنوان نام خاصیت‌هایشان استفاده می‌کنند.

البته بعضی خاصیت‌ها در آرایه‌ها وجود دارند که نام‌گذاری شده‌اند؛ مانند length و بعضی دیگر. متد‌ها توابعی هستند که در خاصیت‌ها قرار دارند و (معمولا) روی مقداری که خاصیتی از آن محسوب می‌شوند عمل می‌کنند.

می‌توانید عناصر یک آرایه را به وسیله نوع خاصی از حلقه‌ی for پیمایش کنید.
for (let element of array)

تمرین‌ها

مجموع یک بازه

در مقدمه‌ی این کتاب، به مثال زیر به عنوان یک راه خوب برای محاسبه‌ی مجموع بازه‌ای از اعداد اشاره شد:

console.log(sum(range(1, 10)));

تابعی به نام range بنویسید که دو آرگومان را دریافت می‌کند، start و end و آرایه‌ای برمی‌گرداند که حاوی تمامی اعدادی است که از start شروع شده و با عدد end پایان می‌یابد.

سپس، تابعی به نام sum بنویسید که آرایه‌ای از اعداد را گرفته و مجموع این اعداد را برمی‌گرداند. برنامه‌ای که در مثال آمده را اجرا کرده و بررسی کنید که آیا 55 را به عنوان پاسخ برمی‌گرداند؟

به عنوان یک ماموریت تشویقی، تابع range خود را تغییر دهید تا آرگومان اختیاری سومی هم قبول کند. این آرگومان گام (step) را برای ساختن آرایه مشخص می‌کند. اگر گامی مشخص نشود، عناصر آرایه، مثل حالت پیش‌فرض، با یک واحد افزایش می‌یابند. فراخوانی تابع به شکل range(1, 10, 2) بایستی خروجی [1, 3, 5, 7, 9] را تولید کند. مطمئن شوید که تابع با گام منفی هم کار خواهد کرد پس range(5, 2, -1) بایستی [5, 4, 3, 2] را تولید کند.

// Your code here.

console.log(range(1, 10));
// → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(range(5, 2, -1));
// → [5, 4, 3, 2]
console.log(sum(range(1, 10)));
// → 55

معکوس کردن یک آرایه

آرایه‌ها متدی به نام reverse دارند که ترتیب عناصر آرایه را معکوس می‌نماید. برای این تمرین، دو تابع بنویسید: reverseArray و reverseArrayInPlace. تابع اول، reverseArray آرایه‌ای را به عنوان ورودی می‌گیرد و آرایه‌ی جدیدی را تولید می‌کند که همان عناصر را دارد اما با ترتیب وارونه. تابع دوم، reverseArrayInPlace مشابه متد reverse عمل می‌کند؛ با این تفاوت که همان آرایه‌ای را که به عنوان آرگومان دریافت می‌کند تغییر می‌دهد و ترتیب عناصرش را عکس می‌کند. در این تمرین نمی‌توانید از متد استاندارد reverse استفاده کنید.

به بحث اثرات جانبی و توابع ناب فکر کنید که در فصل قبل بحث شد، به نظر شما کدام تابع از موارد بالا در موقعیت‌های بیشتری کاربرد خواهد داشد؟ کدام سریع‌تر عمل می‌کند؟

// Your code here.

console.log(reverseArray(["A", "B", "C"]));
// → ["C", "B", "A"];
let arrayValue = [1, 2, 3, 4, 5];
reverseArrayInPlace(arrayValue);
console.log(arrayValue);
// → [5, 4, 3, 2, 1]

لیست

اشیاء به عنوان مقادیری بدون چارچوب خاص، می‌توانند برای ساختن هر نوع ساختار داده استفاده شوند. یکی از انواع رایج ساختار داده، لیست است (نباید لیست را با آرایه اشتباه گرفت). یک لیست مجموعه‌ای تودرتو از اشیاء است که در آن اولین شیء ارجاعی به دومین، دومین به سومین و الی آخر را نگه داری می‌کند.

let list = {
  value: 1,
  rest: {
    value: 2,
    rest: {
      value: 3,
      rest: null
    }
  }
};

اشیائی که در یک زنجیره وجود دارند به این شکل خواهند بود:

یکی از نکات خوب لیست‌ها این است که آن‌ها بخشی از ساختارشان را به اشتراک می‌گذارند. به عنوان مثال، اگر من دو مقدار جدید ایجاد کنم {value: 0, rest: list} و {value: -1, rest: list} (که list در اینجا متغیری است که پیش‌تر تعریف شده است)، هر دوی آن‌ها لیست‌های مستقلی هستند، اما ساختاری را به اشتراک می‌گذارند که سه عنصر آخرشان را می‌سازد. لیست اصلی همچنین هنوز یک لیست سه عنصره‌ی معتبر است.

تابعی به نام arrayToList بنویسید که با دریافت مقدار آرایه‌ای مانند [1, 2, 3] به عنوان آرگومان، یک ساختار لیست شبیه لیستی که نشان داده شد بسازد. همچنین تابعی به نام listToArray بنویسید که آرایه‌ای از لیست داده شده تولید کند. بعد تابع کمکی prepend را تعریف کنید که یک عنصر به همراه یک لیست را گرفته و لیست جدیدی تولید می‌کند که عنصر مورد نظر در ابتدای آن اضافه شده است و تابع nth که یک لیست و یک عدد را گرفته و عنصری که در موقعیت خواسته شده قرار دارد را از لیست برمی‌گرداند (صفر به عنصر اول اشاره می‌کند) یا اینکه در صورت نبودن عنصر، مقدار undefined برگردانده می‌شود.

اگر به روش بازگشتی این مسئله را حل نکرده‌اید، اکنون نسخه‌ی بازگشتی تابع nth را هم بنویسید.

// Your code here.

console.log(arrayToList([10, 20]));
// → {value: 10, rest: {value: 20, rest: null}}
console.log(listToArray(arrayToList([10, 20, 30])));
// → [10, 20, 30]
console.log(prepend(10, prepend(20, null)));
// → {value: 10, rest: {value: 20, rest: null}}
console.log(nth(arrayToList([10, 20, 30]), 1));
// → 20

for (let node = list; node; node = node.rest) {}

مقایسه عمیق

عملگر == اشیاء را بر اساس همسانی مقایسه می‌کند. اما گاهی ممکن است بخواهید مقدار‌های خاصیت‌های واقعی آن‌ها را مقایسه کنید.

تابعی به نام deepEqual بنویسید که دو مقدار را دریافت می‌کند و زمانی مقدار true را برمی‌گرداند که هر دوی مقدار‌ها مشابه باشند یا اگر شیء هستند خاصیت‌های یکسانی داشته باشند، به طوریکه مقدار‌های خاصیت‌های آن‌ها نیز در صورت مقایسه با یک فراخوانی بازگشتی تابع deepEqual، برابر باشند.

برای اینکه بدانیم آیا مقدار‌ها باید مستقیما باهم مقایسه شوند (از عملگر === برای آن استفاده کنید) یا اینکه خاصیت‌هایشان را باید مقایسه کنیم، می‌توان از عملگر typeof استفاده کرد. اگر این عملگر “object” برای هر دو مقدار تولید کرد، بایستی عمل مقایسه‌ی عمیق انجام شود. راستی باید یک استثناء احمقانه را هم نیز در نظر بگیرید: به دلیل اتفاقی قدیمی، typeof null نیز “object” را تولید می‌کند.

وقتی برای مقایسه‌ی خاصیت‌های اشیاء لازم است که به خاصیت‌ها دسترسی پیدا کنید، تابع Object.keys به شما کمک خواهد کرد.

// Your code here.

let obj = {here: {is: "an"}, object: 2};
console.log(deepEqual(obj, obj));
// → true
console.log(deepEqual(obj, {here: 1, object: 2}));
// → false
console.log(deepEqual(obj, {here: {is: "an"}, object: 2}));
// → true