Reja: Javascriptda o’zgaruvchilar haqida umumiy ma’lumot

Qatorlar

Qator bu belgilar ketma-ketligidir. Dastur kodida qator literali orqali ifodalanadi va qo’shtirnoq — “” yoki tirnoq ‘’ belgilari bilan yopiladi.

JavaScriptda qatorlarni bir necha qatorda ifodalash uchun \ belgidan foydalaniladi.

Shuningdek, \ belgidan qator orasida ‘’ yoki “” dan foydalanish uchun qo’llash mumkin. Bu yuqoridagi belgilarni qatorni ochib-yopuvchi begilardan ajratib turadi.

Mantiqiy tip

JavaScript mantiqiy tiplarni ifodalash uchun true yoki false kalit so’zlaridan foydalanadi. Taqqoslash operatorlari (===, ==, <, >) yuqoridagi ikkisidan birini natija sifatida qaytaradi.
if, while kabi tekshiruvchi operatorlar dastur jarayonida mantiqiy tiplardan foydalanadi.
Mantiqiy qiymat ifodani faqat aniq rost yoki yolg’onligida emas, balki rostr yoki yolg’onga yaqin ekanligiga qarab ham aniqlab oladi. Masalan, quyidagi qiymatlarning barchasi yolg’onga yaqin bo’lgani uchun false qiymati olinadi:

null

null hech qanday qiymat yo’qligini bildiruvchi maxsus qiymat.
Bu qiymat deyarli barcha dasturlash tillarida uchraydi. Masalan Pythonda None shaklida uchraydi.

undefined

undefined o’zgaruvchini initsializatsiya qilinmaganligi va qiymat noaniq ekanligini bildiradi.
Funksiyaning qaytaruvchi qiymati bo’lmaganda undefined qaytaradi. Shuningdek, funksiya parametri mavjud bo’lsa, lekin funksiya chaqirilganda unga qiymat yuborilmasa, funksiya parametrlarni undefined holatiga o’tkizadi.
Qiymatni undefined ekanligi quyidagicha tekshiriladi:
Murakkab tiplar
Yuqorida sanab o’tilgan tiplardan boshqa hammasi murakkab tiplar hisoblanadi. Bular funksiyalar, massivlar va obyektlar. Har birining o’ziga xos jihatlari bor, shuningdek ular obyektni xususiyatlariga ham egalik qiladi.
JavaScript tilida o'zgaruvchilar bilan ishlash quyidagi xususiyatlarga ega:
O'zgaruvchi nomi: O'zgaruvchini aniqlash uchun nom yoziladi. Nomlar birinchi harfi katta yoki kichik harf bo'lishi mumkin. O'zgaruvchi nomida probel (bo'sh joy), chiziq (-) yoki boshqa belgilar ishlatilmaydi. Nom faqat harflardan, raqamlardan va $ belgisi ishlatilishi mumkin.
Qiymati: O'zgaruvchiga qanday qiymat berilishi kerakligi yoziladi. Qiymat sifatlari matn (string), son (number), mantiqiy qiymat (boolean) yoki boshqa obyektlar bo'lishi mumkin.
Obyekt turi: JavaScript obyektlari yordamida, bir nechta o'zgaruvchilar va funksiyalarni birlashtirish mumkin.
Vaqti kelganida qiymati o'zgartirish mumkin: O'zgaruvchiga boshlang'ich qiymat berildikdan keyin, u o'zgartirilishi mumkin. Bu yordamda, o'zgaruvchi qiymatini "=". belgisi yordamida o'zgartirish mumkin.
O'zgaruvchiga murojat: O'zgaruvchiga murojat qilish uchun, nomining oldiga "$" belgisi yozilishi kerak. Bunday belgining yozilishi kerak emas, lekin bu usul o'zgaruvchini aniqlashda ko'proq aniqlik yaratadi.
Quyidagi misol kodda "x" va "y" o'zgaruvchilari aniqlangan. "x" ning boshlang'ich qiymati 5, "y" ning boshlang'ich qiymati esa 10. Keyingi qatorda "x" o'zgaruvchisining qiymati o'zgartiriladi, keyingi qatorda esa "x" va "y" o'zgaruvchilari yig'indisi natijasini chop etadi.
let x = 5;
let y = 10;
x = 8;
let sum = x + y;
console.log(sum); // 18
Shuningdek, obyektlar yordamida bir nechta o'zgaruvchini birlashtirish mumkin:
let user = {
name: "John",
age: 30,
isAdmin: true
};
console.log(user.name); // "John"
console.log(user.age); // 30
console.log(user.isAdmin); // true
JavaScript dasturlash tilida o'zgaruvchilarni e'lon qilishning 4 xil usuli bor bo'lib quyidagilar kiradi.

• 
  var
  
• 
  let
  
• 
  const
  
• 
  hech narsa ishlatmasdan
  

O'zgaruvchilar - bu ma'lumotlarni saqlash uchun konteynerlar (ma'lumotlar qiymatlarini saqlash). Ushbu misolda, x, yva z, o'zgaruvchilar bo'lib, ular varkalit so'z bilan e'lon qilinadi:
var x = 5;
var y = 6;
var z = x + y;
Ushbu misolni let kalit so'zi bilan e'lon qilishga misol keltiramiz.
let x = 5;
let y = 6;
let z = x + y;
Ushbu misolda, x, yva z, e'lon qilinmagan o'zgaruvchilar:
x = 5;
y = 6;
z = x + y;
JavaScript da const ni qachon foydalanish kerak?
Kod yozish jarayonida umumiy qoida bo'lishini hohlasangiz ushbu holatda siz const kalit so'zi bilan o'zgaruvchini e'lon qilsangiz bo'ladi. Bunda o'zgaruvchini o'zgartirib bo'lmaydi. Misol uchun PI ni qiymati o'zgarmas bo'lib uni const bilan e'lon qilishimiz mumkin.
const PI = 3.14;
JavaScript da var ni qachon ishlatish kerak?
Har doim JavaScript o'zgaruvchilarini var va let yoki const bilan e'lon qiling. var kalit so'zi 1995 yildan 2015 yilgacha barcha JavaScript kodlarida qo'llaniladi. let kalit so'zi 2015 yildan boshlab JavaScript kodlarida qo'llaniladi. Agar siz eski browser ishlatsangiz u holda var kalit so'zidan foydalanishingiz zarur bo'ladi.
Dasturlashda o'zgaruvchi - bu ma'lumotlarni saqlash uchun container (saqlash maydoni). Masalan:
let num = 5;
Bu yerda num 5 sonini ushlab turuvchi o'zgaruvchidir.
JavaScript da o'zgaruvchilar e'lon qilish
JavaScriptda biz o'zgaruvchilarni e'lon qilish uchun var va let kalit so'zlaridan foydalanamiz. Masalan:
var x;
let y;
Bu yerda x va y o'zgaruvchilar.
JavaScript var va let var va let ikkalasi ham o'zgaruvchini e'lon qilish uchun ishlatiladi. Biroq, ular orasida ba'zi farqlar mavjud.
var JavaScript-ning eski versiyalarida ishlatiladi
let bu JavaScriptning ES6 (ES2015) versiyasidan boshlab o'zgaruvchini e'lon qilishning yangi usuli.
var funktsiyani qamrab oladi (keyingi maqolalarda bu haqida batafsil bilib olasiz)
let blockni qamrab oladi (keyingi maqolalarda bu haqida batafsil bilib olasiz)
Izoh: var o'rniga let dan foydalanish tavsiya etiladi. Biroq, let-ni qo'llab-quvvatlamaydigan bir nechta brauzerlar mavjud. Qo'shimcha ma'lumot olish uchun ushbu sitega tashrif buyuring.
JavaScript-da o'zgaruvchilarga qiymat berish
O'zgaruvchiga qiymat berish uchun biz tayinlash operatori = dan foydalanamiz.

let x;
x = 5;

Bu yerda 5 x o'zgaruvchiga qiymat sifatida berilgan. O'zgaruvchilarni e'lon qilayotganda ham ularga qiymat berishingiz mumkin:
let x = 5;
let y = 6;
JavaScript-da o'zgaruvchilarni bitta statement da e'lon qilish mumkin.
let x = 5, y = 6, z = 7;
Agar siz o'zgaruvchiga qiymat bermasdan foydalansangiz, o'zgaruvchi undefined  qiymatga ega bo'ladi.
let x; // x o'zgaruvchining nomi
console.log(x); // undefined
Bu yerda x o'zgaruvchining nomi va u hech qanday qiymatga ega bo'lmaganligi sababl undefined bo'ladi. Undefined va boshqa ma'lumotlar turlari haqida keyingi qo'llanmada batafsil bilib olasiz.
O'zgaruvchilarning qiymatini o'zgartirish
O'zgaruvchida saqlangan qiymatni o'zgartirish mumkin. Masalan:
// x o'zgaruvchiga 5 qiymat sifatida berilgan
let x = 5;
console.log(x); // 5

// x ning qiymati 3 ga o'zgardi

x = 3;
console.log(x); // 3
JavaScriptda o'zgaruvchilariga nom berish qoidalari O'zgaruvchilarni nomlash qoidalari:
1. O'zgaruvchi nomlari harf, pastki chizig' _ yoki $ dollar belgisi bilan boshlanishi kerak. Masalan:
let a = 'hello';
let _a = 'hello';
let $a = 'hello';
2. O'zgaruvchi nomlarini raqamlardan boshlash mumkin emas. Masalan:
let 1a = 'hello'; // Error!
3. JavaScript case-sensetivedir (ya'ni JS y bilan Y ni farqlay oladi). Shunday qilib y va Y har xil o'zgaruvchi nomlaridir. Masalan:
let y = "Assalamu alaykum";
let Y = 5;

console.log(y); // Assalamu alaykum

console.log(Y); // 5
4. Kalit so'zlarni o'zgaruvchi nomlari sifatida foydalanish mumkin emas. Masalan:
let new = 5; // Error! new bu JS da kalit so'z
O'zgaruvchilarni xohlagan usulda nomlashingiz mumkin bo'lsa-da, o'zgaruvchini tavsiflovchi nom berish yaxshiroqdir. Agar siz apple(olma) sonini saqlash uchun o'zgaruvchidan foydalanayotgan bo'lsangiz, x yoki n o'rniga apple yoki numberOfApples dan foydalanishingiz yaxshiroqdir.
JavaScript-da, o'zgaruvchi nomlari odatda bir nechta so'zlardan iborat bo'lsa, camelCase usulida yoziladi.
Masalan, firstName, annualSalary va boshqalar.
JavaScriptda Constants(konstantlar)
Const kalit so'zi konstantlarni yaratish uchun JavaScriptni ES6 (ES2015) versiyasida kiritilgan. Masalan:
const x = 5;
Konstant e'lon qilingandan so'ng, biz uning qiymatini o'zgartira olmaymiz.
const x = 5;
x = 10; // Error! konstantlarning qiymatini o'zgartirish mumkin emas.
console.log(x)
Oddiy qilib aytganda, konstant - bu qiymati o'zgarishi mumkin bo'lmagan o'zgaruvchi turi. Bundan tashqari, konstantga qiymat bermasdan konstant e'lon qila olmaysiz. Masalan:
const x; // Error! const e'lon qilganingizda qiymat berishni unutdingiz
x = 5;
console.log(x)
Indentifikatorga biriktirilgan literal o'zgaruvchi deb hisoblanadi, ulardan dasturning keyingi ko'rinishi mumkin.
Tiplar
Siz JavaScriptni tipizatsiyaga ega emas deb eshitgan bo'lishi mumkin. Oldin ham ta'kidlaganimdek, bu noto'g'ri. JavaScript tipizatsiya ega, va aynan “dimik tipizatsiya” sifatli ishlaydi. Bu degani, siz bir o'zgaruvchiga olib borish tipni o'zlashtirishingiz mumkin. JavaScriptda ikki xil tiplar mavjud: oddiy va murakkab tiplar.
JavaScript mantiqiy tiplarni ifodalash uchun true yoki false kalit so'zlaridan olinadi. Taqqoslash operatorlari ( ===, ==, <, >) yuqoridagi ikkisidan biriga natija sifatida qaytaradi.
if, while kabi ustidagi operatorlar dastur jarayonida mantiqiy tiplardan.
Mantiqiy qiymat ifodani faqat aniq rost yoki yolg'onligida emas, balki rostr yoki yolg'onga yaqinga qarab ham aniqlab oladi. Masalan, hisob-kitoblarning hammasi yolg'onga yaqin bo'lgan natijalar uchun :
0
-0
NaN
undefined
null
'' // bo'sh qator
Qolgan barcha haqiqiy mahsulot.
null
null hech qanday qiymat yo'qligini bildiruvchi maxsus qiymat.
Bu bahoga barcha dasturlash tillarida. Masalan, Pythonda None tufayli.
aniqlanmagan
undefined o'zgaruvchini initsializatsiya qilinmaganligi va qiymat noaniq baho bildiradi.
Funksiyaning qaytaruvchi qaytaruvchi bo'lmaganda undefined qaytaradi. funktsiya, funksiya parametri mavjud bo'lsa, lekin funksiya chaqirilganda unga qiymat yuborilmasa, funksiyalarni undefined holatiga o'tkizadi.
Qiymatni undefined tekshiriladi:
typeof var === "aniqlanmagan"
Murakkab tiplar
Yuqorida sanab o'tilgan tiplardan boshqa hammasi murakkab tiplar. Bular funktsiyalari, massivlar va obyektlar. Har birining oziga xos xususiyati bor', ular obyektni xususiyatlariga ham egalik qiladi.
Ifodalar
Dasturiy kodning yangi qiymat yaratuvchi qismi deb ifodalanadi.
JavaScriptda ifodalarni bir necha turlari mavjud.
Arifmetik ifodalar
O'zgacha bo'lgan o'zgacha ifodalar:
1/2
i++
i -= 2
i * 2
Qator ifodalari
Qatorlar ustida bajariladigan ifodalar
'Bu ' + 'qator'
s += 'qator'
Birlamchi ifodalari
Bu turga ko'rinishlar, literal va konstantalar kiradi:
6
2.06
'bu nimadir'
true
this //joriy obyekt
undefined
i
tezligi, ba'zi kalit so'zlari
function
class function* // boshqa
generatori yoki iteratorga
yo'funksiyadi async function* //asinxron funksiya ifodasi await () //guruhlash
Massiv va obyekt initsializatsiya ifodalari
[] //massiv harfi
{} //
[1, 2, 3]
{a: 1, b: 2}
{a: {b: 1}}
Mantiqiy ifodalar
Mantiqiy ifodalar operatorlar yordamida mantiqiy qiymatni hosil qiladi
a && b
a || b
!a
Chap-tomon ifodalari
new // konstruktordan yangi model
super // ota konstruktorni chaqiradi
…obj
Xususiyatga murojat ifodalari
object.property
obyekti[xususiyat]
obyekti['mulk']
Obyekt ifodalari
new object()
new a(1)
Funksiya ta'rifi ifodalari
funktsiya() {}
funktsiya (a, b) { qaytish a * b }
(a, b) => a * b
a => a * 5
() => { qaytish 5 }
Funksiya chaqiruv ifodalari
ax(5)
window.resize()
JavaScriptda o'zgaruvchilarga hech qanday tip biriktirilmaydi. Biron-bir tipdagi qiymatni o'zlashtirgandan so'ng o'zgaruvchiga boshqa tipdagi narxni bersangiz hech qanday xatolik yuz bermaydi va o'zgaruchi yangi tipni o'zlashtirmaydi. Buning uchun JavaScriptni ba'zida tipizatsiyaga ega emas deyishadi. Ammo bu Java noto'g'ri, tipizatsiyaga ega va “dinamik tipizatsiya” asosida ishlaydi.
O'zgaruvchidan yuklash uchun uni avval e'lon qilish kerak. JavaScript buni 3 xil usulda amalga oshirish mumkin: var, let yoki const kalit'lari orqali. Bularning har biri turli sabablarga ko'ra.
Var orqali e'lon qilish
ES2015 gacha varo'zgaruchini e'lon qilishning yagona yo'li bo'lgan.
var a = 0
Agar var so'zini qo'yishni unutasiz, siz e'lon qilinmagan o'zgaruvchiga qiymat berayotgan bo'lasiz va natija siz kutgandek bo'lmaydi. Zamonaviy muhitlarda yoki strict rejimini tezlashtiradigan bo'lsa, yuqoridagi holatda xatolik yuz beradi. Eski muhitlarda (yoki strict rejimi o'chirilgan bo'lsa), o'zgaruvchini initsializatsiya qiladi va global obyektga biriktirib qo'yadi. Qo'shimcha ma'lumot uchun, initsializatsiya — o'zgaruvchiga dastlabki qiymatini o'zashtirish jarayoni.
o'zgaruvchini e'lon qilganda uni initsializatsiya qilmasangiz, u undefined xavfsizlikni o'z nazorati va unga yangi qiymat bermaguningizcha bu holatni saqlab turadi.
var a // typeof a === 'aniqlanmagan'
Bir o'zgaruvchini bir necha marta e'lon qilish mumkin, bunda oldindan kor ichida:
var a = 1
var a = 2
Bir qatorda bir nechta o'zgaruvchilarni e'lon boshqarish ham mumkin:
var a = 1, b = 2
Dasturlashda “scope” sohasi mavjud, o'zbek tiliga ko'rinishlari deb tarjima qilsak bo'ladi (IMHO). Ko'rinish sohasi deganda o'zlashtiruvchi ko'rinadigan va foydalansa bo'ladigan dastur qismiiladi.
Funksiyadan tashqarida var soha orqali e'lon qilingan o'zgaruvchi global obyektga biriktiriladi va global ko'rinishga ega bo'ladi. Bunday o'zgaruvchidan dasturning ko'rinishida foydalanish mumkin. Agar var orqali funksiya ichida e'lon boshqaruv, o'zgaruvchi funksiyaga yig'iladi va u faqat funksiya ichida ishlaydi, funksiya parametri kabi.
Agar funksiya ichida globaldagi o'zgaruvchi bilan bir xil nomdagi o'zgaruvchi e'lon shaxsiy funksiya, shaxsiy ustunlikka va global o'zgaruvchini inkor qilib yuboradi.
Shuni ta' qayd muhimki, { } qavslar bilan ajratilgan blok yaratganiz bilan ko'rinish sohasi (scope) yaratilmaydi. Funksiya yaratganingizdagina ko'rinish sohasi yaratiladi, chunki var blok ko'rinish sohasiga ega emas, balki funksiyaviy ko'rinish sohaga ega.
Funksiya ichida e'lon qilingan o'zgaruvchi funksiyasi bo'ylab yordam olish mumkin. Xattoki, funksiyasi ohirida e'lon shaxsiy ham funksiyasidan yuk tashish mumkin, chunki JavaScript kodni jamlashdan barcha o'zgaruvchilarni yuqoriga ko'chiradi. Lekin chalg'ib ketmas uchun o'zgaruvchini funksiyasi e'lon qilganingiz maqul.
yo'l orqali e'lon qilish
Yuqorida aytganimizdek, var blok ko'rinish sohasiga ega emas. Bu muammoni hal qilish uchun ES2015 da let qo'shilgan. let orqali e'lon qilngan o'zgaruvchining ko'rinish sohasi faqat o'zi e'lon qilgan blokka hamda undagi ichki bloklarga tegishli.
Zamonaviy dasturchilar, asosan, let dangina ketmoqda, va var dan butunlay voz kechishmoqda.
Yana bir farqi, funksiyasi let orqali e'lon qilganizda, var dan farqli o'laroq o'zgaruvchini global o'zgar uvchiga aylantirmaydi.
Const orqali e'lon qilish
var yoki let e'lon qilingan o'zgaruvchilar yordamni o'zgartirishi mumkin. Const da e'lon qilingan o'zgaruvchi initsializatsiya qilingandan keyin boshqa o'zgarmaydi va uni o'zgarmas qiymatga aylantiradi, ya'ni konstantaga .
const a = "sinov"
aconst ga yordam literalni biriktirish mumkin. Yana bir jihati: agar a konstantaga obyekt biriktirilgan bo'lsa, undagi funktsiyalari orqali obyekt qiymatlarini o'zgartirsa bo'ladi.
Const ko'rsatmani o'zgartiruvchi mas'uliyatni ta'minlash. kabi let blok ko'rinish sohasiga ega.
Zamonaviy dasturchilar dastur asosida o'zgarmaydigan o'zgaruvchilarni const da e'lon ma'qul ko'rishadi, chunki bu keyiknchalik uchrashi mumkin bo'lgan xatoliklarni oladi.
Var
JavaScriptda o'zgaruvchilar e'lon qilishning eski yo'li. ES2015 versiyasigacha yagona keyword hisoblangan. Biz var bilan yaratilgan o'zgaruvchilarni e'lon qilishimiz, xohlagan turdagi ma'lumotni biriktirishimiz va o'sha ma'lumotni xohlaganimizcha o'zgartirishimiz mumkin. var o'zgaruvchilari asosan global o'zgaruvchilar yaratish uchun ishlatiladi, va ularning qamrovi funksiya oralig'ida (function scope). Ya'ni, agar bizning funksiyamizda biror var bilan yaratilgan o'zgaruvchi bo'lsa, biz uni o'sha funksiyaning tashqarisida foydalanolmaymiz.
var city = "Qarshi";
console.log(city); // Qarshi

var city = "Toshkent";

console.log(city); // Toshkent
Yuqorida ko'rganingizdek, garchi o'zgaruvchilarimizning nomlari bir xil bo'lsa ham, biz xohlaganimizdek ularni o'zgartirishimiz mumkin. Va bu var ning xavfli tomoni hisoblanadi.
Let
let ham var kabi vazifani bajaradi, lekin ularni orasida jiddiy farqlar bor.
let bilan yaratilgan o'zgaruvchilarga yangi data yoki ma'lumot biriktirsak bo'ladi lekin bu o'zgaruvchilarni qayta e'lon qilib bo'lmaydi. Masalan:
let sport = "football";
console.log(sport); // football
// endi "sport" o'zgaruvchisiga yangi ma'lumot biriktiramiz
sport = "karate"
console.log(sport) // karate
// endi uni qayta e'lon qilamiz
let sport = "boxing"
console.log(sport) // SyntaxError: Identifier 'sport' has already been declared
Keyingi farq "ko'tarilish" (hoisting) mavzusiga bog'liq. Qisqacha qilib aytganda, let o'zgaruvchilarini biz e'lon qilmasimizdan oldin qabul qilolmaymiz. Hoisting haqida keyingi darslarda atroflicha to'xtalamiz. Quyida var var let orasidagi farqni ko'rishingiz mumkin:
console.log(number); // undefined
var number = 10;
console.log(number); // 10
console.log(number); //Reference Error: Cannot access 'number' before initialization
let number = 10;
// yoki const number = 10
console.log(number); // 10
Keyingi farqi bu let o'zgaruvchilarining qamrovi (scope) "block" qamroviga ega. Ya'ni, ularni har qanday { } qavslari tashqarisidan qabul qilolmaymiz. var o'zgaruvchilarining qamrovi esa "function scope" ya'ni funksiya qamroviga ega. Quyida bu farqni ko'rishingiz mumkin:
function fn(){
var number = 5;
};
console.log(number); // Reference Error: number is not defined
// Chunki number o'zgaruvchisini funksiya tashqarisidan chaqiryapmiz
{
var number2 = 15;
}
console.log(number2); // 15 -> chunki number2 funksiya ichida emas
function fn() {
let number = 5;
}
console.log(number); // Referece Error: number is not defined
{
let number2 = 15;
}

console.log(number2); // Referece Error: number2 is not defined

Const
const - nomlanishi kabi "constant" ya'ni "o'zgarmas" degan tarjimani beradi. let o'zgaruvchisi bilan qamrov borasida bir xil ya'ni const qamrovi ham "block scope { }". Farqi shundaki, const o'zgaruvchilariga biz yangi ma'lumot biriktirolmaymiz.
const name = "Anna";
name = "Janna";
console.log(name); // TypeError: Assignment to constant variable.