3. مبانی جاوااسکریپت

توجه: از این پس، اصطلاح [Javascript] همیشه به استاندارد ECMAScript 6 اشاره خواهد داشت.

در پروژهٔ قبلی JavaScript، یک پوشه به نام [bases] ایجاد کنید. ما مثال‌های این بخش را در آنجا قرار خواهیم داد:

3.1. اسکریپت [bases-01]

برای معرفی مبانی PHP7، از کد زیر استفاده کردیم (به پاراگراف «link» مراجعه کنید):


<?php

//این یک نظر است
// متغیری که بدون تعریف شدن استفاده شده است
$nom = "dupont";
//یک نمایش صفحه
print "nom=$nom\n";
// یک آرایه با عناصر از انواع مختلف
$tableau = array("un", "deux", 3, 4);
// تعداد عناصر آن
$n = count($tableau);
//یک حلقه
for ($i = 0; $i < $n; $i++) {
  print "tableau[$i]=$tableau[$i]\n";
}
// ابتدایی‌سازی دو متغیر با محتویات یک آرایه
list($chaine1, $chaine2) = array("chaine1", "chaine2");
//الحاق دو رشته
$chaine3 = $chaine1 . $chaine2;
// نمایش نتیجه
print "[$chaine1,$chaine2,$chaine3]\n";
// استفاده از یک تابع
affiche($chaine1);
// نوع یک متغیر ممکن است مشخص باشد
afficheType("n", $n);
afficheType("chaine1", $chaine1);
afficheType("tableau", $tableau);
// نوع یک متغیر می‌تواند در زمان اجرا تغییر کند
$n = "a changé";
afficheType("n", $n);
// یک تابع می‌تواند یک نتیجه بازگرداند
$res1 = f1(4);
print "res1=$res1\n";
//یک تابع می‌تواند آرایه‌ای از مقادیر را بازگرداند
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
//این مقادیر می‌توانستند در یک آرایه بازیابی شده باشند
$t = f2();
for ($i = 0; $i < count($t); $i++) {
  print "t[$i]=$t[$i]\n";
}
// آزمون‌ها
for ($i = 0; $i < count($t); $i++) {
  // فقط رشته‌ها را نمایش می‌دهد
  if (getType($t[$i]) === "string") {
    print "t[$i]=$t[$i]\n";
  }
}
// عملگرهای مقایسه == و ===
if("2"==2){
  print "avec l'opérateur ==, la chaîne 2 est égale à l'entier 2\n";
}else{
  print "avec l'opérateur ==, la chaîne 2 n'est pas égale à l'entier 2\n";
}
if("2"===2){
  print "avec l'opérateur ===, la chaîne 2 est égale à l'entier 2\n";
}
else{
  print "avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2\n";
}
// آزمایش‌های بیشتر
for ($i = 0; $i < count($t); $i++) {
  //فقط اعداد صحیح بزرگ‌تر از ۱۰ را نمایش می‌دهد
  if (getType($t[$i]) === "integer" and $t[$i] > 10) {
    print "t[$i]=$t[$i]\n";
  }
}
//یک حلقه while
$t = [8, 5, 0, -2, 3, 4];
$i = 0;
$somme = 0;
while ($i < count($t) and $t[$i] > 0) {
  print "t[$i]=$t[$i]\n";
  $somme += $t[$i];   //$somme=$somme+$t[$i]
  $i++;               //$i=$i+1
}//در حالی که
print "somme=$somme\n";

//پایان برنامه
exit;

//----------------------------------
function affiche($chaine) {
  //نمایش می‌دهد $chaine
  print "chaine=$chaine\n";
}

//نمایش می‌دهد
//----------------------------------
function afficheType($name, $variable) {
  // نوع $variable را نمایش می‌دهد
  print "type[variable $" . $name . "]=" . getType($variable) . "\n";
}

//afficheType
//----------------------------------
function f1($param) {
  // عدد ۱۰ را به $param اضافه می‌کند
  return $param + 10;
}

//----------------------------------
function f2() {
  // ۳ مقدار برمی‌گرداند
  return array("un", 0, 100);
}
?>

این کد به زبان جاوااسکریپت تبدیل شده و کد زیر را ایجاد می‌کند:


'use strict';
// این یک نظر است
//ثابت
const nom = "dupont";
//یک نمایش صفحه
console.log("nom : ", nom);
// یک آرایه با عناصر از انواع مختلف
const tableau = ["un", "deux", 3, 4];
// تعداد عناصر آن
let n = tableau.length;
//یک حلقه
for (let i = 0; i < n; i++) {
  console.log("tableau[", i, "] = ", tableau[i]);
}
// ابتکاریزه‌سازی دو متغیر با محتویات یک آرایه
let [chaine1, chaine2] = ["chaine1", "chaine2"];
//الحاق دو رشته
const chaine3 = chaine1 + chaine2;
// نمایش نتیجه
console.log([chaine1, chaine2, chaine3]);
// استفاده از یک تابع
affiche(chaine1);
// نوع یک متغیر ممکن است مشخص باشد
afficheType("n", n);
afficheType("chaine1", chaine1);
afficheType("tableau", tableau);
// نوع یک متغیر می‌تواند در زمان اجرا تغییر کند
n = "a changé";
afficheType("n", n);
// یک تابع می‌تواند یک نتیجه بازگرداند
let res1 = f1(4);
console.log("res1=", res1);
//یک تابع می‌تواند آرایه‌ای از مقادیر را بازگرداند
let res2, res3;
[res1, res2, res3] = f2();
console.log("(res1,res2,res3)=", [res1, res2, res3]);
//این مقادیر می‌توانستند در یک آرایه بازیابی شوند
let t = f2();
for (let i = 0; i < t.length; i++) {
  console.log("t[i]=", t[i]);
}
// آزمون‌ها
for (let i = 0; i < t.length; i++) {
  // فقط رشته‌ها را نمایش می‌دهد
  if (typeof (t[i]) === "string") {
    console.log("t[i]=", t[i]);
  }
}
// عملگرهای مقایسه‌ای == و ===
if ("2" == 2) {
  console.log("avec l'opérateur ==, la chaîne 2 est égale à l'entier 2");
} else {
  console.log("avec l'opérateur ==, la chaîne 2 n'est pas égale à l'entier 2");
}
if ("2" === 2) {
  console.log("avec l'opérateur ===, la chaîne 2 est égale à l'entier 2");
} else {
  console.log("avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2");
}
// آزمایش‌های بیشتر
for (let i = 0; i < t.length; i++) {
  //فقط اعداد صحیح بزرگ‌تر از ۱۰ را نمایش می‌دهد
  if (typeof (t[i]) === "number" && Math.floor(t[i]) === t[i] && t[i] > 10) {
    console.log("t[i]=", t[i]);
  }
}
//یک حلقه while
t = [8, 5, 0, -2, 3, 4];
let i = 0;
let somme = 0;
while (i < t.length && t[i] > 0) {
  console.log("t[i]=", t[i]);
  somme += t[i];
  i++;
}
console.log("somme=", somme);

// برنامه متوقف می‌شود زیرا دیگر کد قابل اجرا وجود ندارد

//نمایش می‌دهد
//----------------------------------
function affiche(chaine) {
  //یک رشته را نمایش می‌دهد
  console.log("chaine=", chaine);
}

//afficheType
//----------------------------------
function afficheType(name, variable) {
  // نوع متغیر را نمایش می‌دهد
  console.log("type[variable ", name, "]=", typeof (variable));
}

//----------------------------------
function f1(param) {
  //مقدار 10 را به پارامتر اضافه می‌کند
  return param + 10;
}

//----------------------------------
function f2() {
  // سه مقدار را بازمی‌گرداند
  return ["un", 0, 100];
}

بیایید با استفاده از اعلان [use strict] (خط ۱) به عنوان مرجع، تفاوت‌های بین کدهای PHP و ECMAScript 6 را بررسی کنیم:

اولین تفاوت این است که در ECMAScript، متغیرها با استفاده از کلیدواژه‌های زیر اعلام می‌شوند:
- [let] برای تعریف متغیری که مقدار آن ممکن است در حین اجرای کد تغییر کند؛
- [const] برای تعریف متغیری که مقدار آن در حین اجرای کد تغییر نخواهد کرد (یعنی یک ثابت)؛
- شما همچنین می‌توانید به جای [let] از کلمه کلیدی [var] استفاده کنید. این کلمه کلیدی با ECMAScript 5 استفاده می‌شد. ما در این دوره از آن استفاده نخواهیم کرد؛
خط ۶: متد نمایش [console.log] می‌تواند انواع داده‌ها را نمایش دهد: رشته‌ها، اعداد، بولین‌ها، آرایه‌ها و اشیاء. متد PHP [print] به‌طور بومی قادر به نمایش آرایه‌ها و اشیاء نیست. در عبارت [console.log]، [console] یک شیء و [log] یک متد از آن شیء است؛
خط ۸: آرایه‌های جاوااسکریپت اشیایی هستند که توسط یک نشانگر به آن‌ها ارجاع داده می‌شود. وقتی می‌نویسیم:


const tableau = ["un", "deux", 3, 4];

متغیر [tableau] یک اشارهگر به آرایه صریح ["un", "deux", 3, 4] است. تغییر محتویات آرایه، اشارهگر آن را تغییر نمی‌دهد. بنابراین، یک آرایه اغلب با استفاده از کلمه کلیدی [const] تعریف می‌شود. در PHP، یک آرایه توسط یک نشانگر ارجاع داده نمی‌شود. این یک مقدار تحت‌اللفظی است؛

خط ۱۲: متغیر حلقه [i] در داخل حلقه تعریف (let) شده است. کلیدواژه [let] به دامنه بلوکی (کد داخل پرانتزهای منحنی) پایبند است. بنابراین، متغیر [i] در خط ۱۲ فقط در داخل حلقه شناخته می‌شود؛
خط ۱۸: عملگر الحاق رشته‌ای در جاوااسکریپت '+' است و در PHP '.' است. ویژگی متمایز این عملگر این است که بر عملگر جمع '+' تقدم دارد. بنابراین:
- در PHP، '1' + 2 عدد 3 را برمی‌گرداند؛
- در جاوااسکریپت، '1' + 2 رشته '12' را برمی‌گرداند؛
خط ۲۰: [console.log] می‌تواند آرایه‌ها را نمایش دهد؛
خط ۸۲: در جاوااسکریپت، مشخص کردن نوع پارامترهای یک تابع امکان‌پذیر نیست؛
خط ۹۱: عملگر [typeof] به شما امکان می‌دهد نوع یک قطعه داده را مشخص کنید. چهار نوع وجود دارد: عدد، رشته، بولی و شیء. توجه داشته باشید که در جاوااسکریپت هیچ نوع [integer] یا [tableau] وجود ندارد. همان‌طور که گفته شد، آرایه‌ها از طریق نشانگرها مدیریت می‌شوند و در دسته اشیاء قرار می‌گیرند؛
خطوط 50–59: همانند PHP، جاوااسکریپت دو عملگر مقایسه دارد، == و '==='، با همان معنایی که در PHP آمده است. ESLint اغلب اپراتور == را به‌عنوان یک خطای احتمالی علامت‌گذاری می‌کند. اپراتور '===' باید همیشه استفاده شود؛
خط ۷۹: می‌توانستیم از دستور [return] استفاده کنیم، اما ESLint هشداری صادر می‌کند که [return] باید فقط درون یک تابع استفاده شود؛

بیایید این کد را اجرا کنیم:

نتایج اجرای کد:


[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe "c:\Temp\19-09-01\javascript\bases\bases-01.js"
nom : dupont
tableau[ 0 ] = un
tableau[ 1 ] = deux
tableau[ 2 ] = 3
tableau[ 3 ] = 4
[ 'chaine1', 'chaine2', 'chaine1chaine2' ]
chaine= chaine1
type[variable n ]= number
type[variable chaine1 ]= string
type[variable tableau ]= object
type[variable n ]= string
res1= 14
(res1,res2,res3)= [ 'un', 0, 100 ]
t[ 0 ]= un
t[ 1 ]= 0
t[ 2 ]= 100
t[ 0 ]= un
avec l'opérateur ==, la chaîne 2 est égale à l'entier 2
avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2
t[ 2 ]= 100
t[ 0 ]= 8
t[ 1 ]= 5
somme= 13

[Done] exited with code=0 in 0.316 seconds

در کد نوشته شده، ESLINT دو خطا گزارش می‌کند:

حرکت دادن مکان‌نما روی خط هشدار قرمز، پیام خطای [3] را نمایش می‌دهد. در اینجا، ESLint تشخیص نمی‌دهد که دو مقدار ثابت با هم مقایسه می‌شوند. یکی از دو عملوند باید یک متغیر باشد؛
در [4]، گزینه‌ای [Quick Fix] به شما امکان می‌دهد که اگر تصمیم بگیرید خطا را اصلاح نکنید، هشدار را نادیده بگیرید؛

در [5]، می‌توانید هشدار را برای خط فعلی یا برای کل فایل غیرفعال کنید. این گزینه دوم است که ما در اینجا انتخاب می‌کنیم. خط [6] سپس در ابتدای فایل تولید می‌شود؛

3.2. اسکریپت [bases-02]

اسکریپت [bases-02] کاربرد کلمات کلیدی [let] و [const] را نشان می‌دهد:


''use strict';
// برای مقداردهی اولیه یک متغیر، از `let` یا `const` استفاده کنید
// 'let' برای متغیرها
let x = 4;
x++;
console.log(x);
// `const` برای ثابت‌ها
const y = 10;
x += y;
//مجاز نیست
y++;

خط ۱۱ در حین اجرای [1-2] خطا ایجاد می‌کند. این خطا توسط ESLint قبل از اجرای [3] علامت‌گذاری می‌شود:

3.3. اسکریپت [bases-03]

اسکریپت [bases-03] دامنه متغیرها را در جاوااسکریپت بررسی می‌کند:


'use strict';
// دامنه متغیرها
let count = 1;
function doSomething() {
  // 'count' در اینجا تعریف شده است
  console.log("count=",count);
}
// فراخوانی
doSomething();

با این حال، متغیر [count] که خارج از تابع [doSomething] تعریف شده است، با این وجود در داخل آن تابع قابل تشخیص است. این یک تفاوت اساسی با PHP است؛

اجرا


[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe "c:\Temp\19-09-01\javascript\bases\bases-03.js"
count= 1

[Done] exited with code=0 in 0.3 seconds

3.4. script [bases-04]

یک متغیر محلی، یک متغیر سراسری با همان نام را مخفی می‌کند:


'use strict';
// دامنه متغیر
const count = 1;
function doSomething() {
  // متغیر محلی متغیر سراسری را مخفی می‌کند
  const count = 2;
  console.log("count inside function=",count);
}
// متغیر سراسری
console.log("count outside function=",count);
// متغیر محلی
doSomething();

اجرا


[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe "c:\Temp\19-09-01\javascript\bases\bases-04.js"
count outside function= 1
count inside function= 2

[Done] exited with code=0 in 0.246 seconds

3.5. script [bases-05]

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


'use strict';
// دامنه متغیر
function doSomething() {
  // متغیر محلی درون تابع
  const count = 2;
  console.log("count inside function=", count);
}
// در اینجا، `count` تعریف نشده است
console.log("count outside function=", count);
doSomething();

ESLint خطای خط 9 را گزارش می‌کند:

3.6. script [bases-06]

کلیدواژه‌های [let] و [const] متغیرهایی را با دامنه [bloc] (کد داخل پرانتزهای منحنی) تعریف می‌کنند اما کلیدواژه [var] این کار را انجام نمی‌دهد:


'use strict';
//کلمه کلیدی [let] برای تعریف یک متغیر با دامنه بلوکی استفاده می‌شود
{
  //متغیر [count] تنها در داخل این بلوک شناخته می‌شود
  let count = 1;
  console.log("count=", count);
}
// در اینجا، متغیر [count] شناسایی نمی‌شود
count++;

// کلمه کلیدی [const] برای تعریف یک متغیر در محدوده بلوک استفاده می‌شود
{
  // متغیر [count2] تنها در داخل این بلوک شناخته شده است
  const count2 = 1;
  console.log("count=", count2);
}
// در اینجا متغیر [count2] شناسایی نمی‌شود
count2++;

// کلمه کلیدی [var] نمی‌تواند برای تعریف یک متغیر در محدوده بلوک استفاده شود
{
  //متغیر [count3] به‌صورت سراسری تعریف خواهد شد
  var count3 = 1;
  console.log("count=", count3);
}
// در اینجا متغیر [count3] شناخته‌شده است
count3++;

نظرات

خط ۵: متغیر [count] تنها در بلوک کدی که در آن تعریف شده است (خطوط ۳–۷) شناخته می‌شود؛
خط ۱۴: مقدار ثابت [count2] تنها در بلوک کدی که در آن تعریف شده است (خطوط ۱۲–۱۶) شناخته می‌شود؛
خط ۲۳: متغیر [count3] خارج از بلوک کدی که در آن تعریف شده است شناخته می‌شود (خطوط ۲۱–۲۵);

ESLint خطاهای زیر را گزارش می‌کند:

به همین دلایل مربوط به دامنه بلوک، از این پس تنها از کلمات کلیدی [let] و [const] استفاده خواهیم کرد.

3.7. script [bases-07]

انواع داده در جاوااسکریپت:


''use strict';

// نوع داده jS
const var1 = 10;
const var2 = "abc";
const var3 = true;
const var4 = [1, 2, 3];
const var5 = {
  nom: 'axèle'
};
const var6 = function () {
  return +3;
}
//نوع نمایش
console.log("typeof(var1)=", typeof (var1));
console.log("typeof(var2)=", typeof (var2));
console.log("typeof(var3)=", typeof (var3));
console.log("typeof(var4)=", typeof (var4));
console.log("typeof(var5)=", typeof (var5));
console.log("typeof(var6)=", typeof (var6));

اجرا


[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe "c:\Temp\19-09-01\javascript\bases\bases-07.js"
typeof(var1)= number
typeof(var2)= string
typeof(var3)= boolean
typeof(var4)= object
typeof(var5)= object
typeof(var6)= function

[Done] exited with code=0 in 0.26 seconds

توضیحات

خط ۷ (کد): یک آرایه یک شیء است. بنابراین، [var4] یک اشاره به آرایه است، نه خود آرایه؛
خط ۸ (کد): [var5] یک اشارهگر به یک شیء صریح است. خواهیم دید که اشیاء صریح جاوااسکریپت شباهت زیادی به نمونه‌های کلاس PHP دارند. آن‌ها نیز از طریق اشارهگر مرجع‌دهی می‌شوند؛
خط ۱۱ (کد): یک متغیر می‌تواند از نوع [fonction] باشد (خط ۷ نتایج);

3.8. اسکریپت [bases-08]

این اسکریپت تبدیل‌های نوع ممکن در جاوااسکریپت را نشان می‌دهد.


'use strict';

//تبدیل‌های ضمنی نوع
// نوع --> بول
console.log("---------------[Conversion implicite vers un booléen]------------------------------");
showBool("abcd");
showBool("");
showBool([1, 2, 3]);
showBool([]);
showBool(null);
showBool(0.0);
showBool(0);
showBool(4.6);
showBool({});
showBool(undefined);

function showBool(data) {
  //تبدیل داده‌ها به بولین به‌طور خودکار در تست زیر انجام می‌شود
  console.log("[data=", data, "], [type(data)]=", typeof (data), "[valeur booléenne(data)]=", data ? true : false);
}

//تبدیل‌های ضمنی نوع به یک نوع عدد ی
console.log("---------------[Conversion implicite vers un nombre]------------------------------");
showNumber("12");
showNumber("45.67");
showNumber("abcd");

function showNumber(data) {
  // داده‌ها + 1 کار نمی‌کند زیرا jS سپس به‌جای جمع، الحاق رشته‌ای انجام می‌دهد
  const nombre = data * 1;
  console.log("[data=", data, "], [type(data)]=", typeof (data), "[nombre]=", nombre, "[type(nombre)]=", typeof (nombre));
}

//تبدیل صریح نوع به بولین
console.log("---------------[Conversion explicite vers un booléen]------------------------------");
showBool2("abcd");
showBool2("");
showBool2([1, 2, 3]);
showBool2([]);
showBool2(null);
showBool2(0.0);
showBool2(0);
showBool2(4.6);
showBool2({});
showBool2(undefined);

function showBool2(data) {
  //تبدیل داده به بولین به‌طور صریح در تست زیر انجام می‌شود
  console.log("[", data, "], [type(data)]=", typeof (data), "[valeur booléenne(data)]=", Boolean(data));
}
// تبدیل صریح نوع به `Number`
console.log("---------------[Conversion explicite vers un nombre]------------------------------");
showNumber2("12.45");
showNumber2(67.8);
showNumber2(true);
showNumber2(null);

function showNumber2(data) {
  const nombre = Number(data);
  console.log("[data=", data, "], [type(data)]=", typeof (data), "[nombre]=", nombre, "[type(nombre)]=", typeof (nombre));
}

//به String
console.log("---------------[Conversion explicite vers un string]------------------------------");
showString(5);
showString(6.7);
showString(false);
showString(null);

function showString(data) {
  const chaîne = String(data);
  console.log("[data=", data, "], [type(data)]=", typeof (data), "[chaîne]=", chaîne, "[type(chaîne)]=", typeof (chaîne));
}

// برخی تبدیل‌های ضمنی غیرمنتظره
console.log("---------------[Autres cas]------------------------------");
const string1 = '1000.78';
//الحاق رشته‌ای پیش‌فرض
const data1 = string1 + 1.034;
console.log("data1=", data1, "type=", typeof (data1));
const data2 = 1.034 + string1;
console.log("data2=", data2, "type=", typeof (data2));
//تبدیل صریح به عدد
const data3 = Number(string1) + 1.034;
console.log("data3=", data3, "type=", typeof (data3));
// true به عدد 1 تبدیل می‌شود
const data4 = true * 1.18;
console.log("data4=", data4, "type=", typeof (data4));
//false به عدد 0 تبدیل می‌شود
const data5 = false * 1.18;
console.log("data5=", data5, "type=", typeof (data5));

اجرا


[Running] C:\myprograms\laragon-lite\bin\nodejs\node-v10\node.exe "c:\Data\st-2019\dev\es6\javascript\bases\bases-08.js"
---------------[Conversion implicite vers un booléen]------------------------------
[data= abcd ], [type(data)]= string [valeur booléenne(data)]= true
[data= ], [type(data)]= string [valeur booléenne(data)]= false
[data= [ 1, 2, 3 ] ], [type(data)]= object [valeur booléenne(data)]= true
[data= [] ], [type(data)]= object [valeur booléenne(data)]= true
[data= null ], [type(data)]= object [valeur booléenne(data)]= false
[data= 0 ], [type(data)]= number [valeur booléenne(data)]= false
[data= 0 ], [type(data)]= number [valeur booléenne(data)]= false
[data= 4.6 ], [type(data)]= number [valeur booléenne(data)]= true
[data= {} ], [type(data)]= object [valeur booléenne(data)]= true
[data= undefined ], [type(data)]= undefined [valeur booléenne(data)]= false
---------------[Conversion implicite vers un nombre]------------------------------
[data= 12 ], [type(data)]= string [nombre]= 12 [type(nombre)]= number
[data= 45.67 ], [type(data)]= string [nombre]= 45.67 [type(nombre)]= number
[data= abcd ], [type(data)]= string [nombre]= NaN [type(nombre)]= number
---------------[Conversion explicite vers un booléen]------------------------------
[ abcd ], [type(data)]= string [valeur booléenne(data)]= true
[ ], [type(data)]= string [valeur booléenne(data)]= false
[ [ 1, 2, 3 ] ], [type(data)]= object [valeur booléenne(data)]= true
[ [] ], [type(data)]= object [valeur booléenne(data)]= true
[ null ], [type(data)]= object [valeur booléenne(data)]= false
[ 0 ], [type(data)]= number [valeur booléenne(data)]= false
[ 0 ], [type(data)]= number [valeur booléenne(data)]= false
[ 4.6 ], [type(data)]= number [valeur booléenne(data)]= true
[ {} ], [type(data)]= object [valeur booléenne(data)]= true
[ undefined ], [type(data)]= undefined [valeur booléenne(data)]= false
---------------[Conversion explicite vers un nombre]------------------------------
[data= 12.45 ], [type(data)]= string [nombre]= 12.45 [type(nombre)]= number
[data= 67.8 ], [type(data)]= number [nombre]= 67.8 [type(nombre)]= number
[data= true ], [type(data)]= boolean [nombre]= 1 [type(nombre)]= number
[data= null ], [type(data)]= object [nombre]= 0 [type(nombre)]= number
---------------[Conversion explicite vers un string]------------------------------
[data= 5 ], [type(data)]= number [chaîne]= 5 [type(chaîne)]= string
[data= 6.7 ], [type(data)]= number [chaîne]= 6.7 [type(chaîne)]= string
[data= false ], [type(data)]= boolean [chaîne]= false [type(chaîne)]= string
[data= null ], [type(data)]= object [chaîne]= null [type(chaîne)]= string
---------------[Autres cas]------------------------------
data1= 1000.781.034 type= string
data2= 1.0341000.78 type= string
data3= 1001.814 type= number
data4= 1.18 type= number
data5= 0 type= number