JavaScript-ის bitwise (ბიტვაიზ) ოპერატორები

დღევანდელ გაკვეთილში ვისაუბრებთ, თუ რა არის და რაში გამოიყენება ჯავასკრიპტში ე.წ. bitwise ოპერატორები, სამწუხაროდ ამ ოპერატორების შესახებ დამწყებმა დეველოპერებმა არც ისე კარგად იციან.

მე შევეცდები მაქსიმალურად დეტალურად ავხსნა, თუ როგორ მუშაობს ეს ოპერატორები შესაბამისი მაგალითების გამოყენებით.

როგორ ინახება ინფორმაცია კომპიუტერში?

როგორც იცით კომპიუტერს მხოლოდ 2 რიცხვის გაგება შეუძლია, ესენია 0 და 1. შესაბამისად კომპიუტერი ჩვენგან განსხვავებით იყენებს თვლის ორობით სისტემას 0-ებისგან და 1-ებისგან შემდგარს.

ჯავასკრიპტი იყენებს 32 ბიტიან სისტემას, 1 ბიტში ინახება მხოლოდ 1 ან 0, მაგალითისთვის თუ ჩვენ გვინდა, რომ რიცხვი 2 დავაკონვერტიროთ ორობით სისტემაში, რომელიც შედგება 32 ბიტისგან, ის გამოიყურება შემდეგნაირად: 00000000 00000000 00000000 00000010.
თუ გაინტერესებთ, თუ რა ფორმულით შეგიძლიათ ათობითი სისტემიდან ორიბითში კონვერტაცია შეგიძლიათ გაეცნოთ მოცემულ ბმულზე მითითებულ ინფორმაციას.

Bitwise ლოგიკური ოპერატორები ჯავასკრიპტში

ჯავასკრიპტში გვაქვს 7 bitwise ოპერატორი, რომლებიც საშუალებას გვაძლევს ორობითი სისტემის დონეზე განვახორციელოთ ლოგიკური ოპერაციები.

ოპერატორი	სახელი	აღწერა
`&`	AND	ბიტს გადააქცევს 1-ად თუ ორივე ბიტის მნიშვნელობებია 1-ია
`\|`	OR	ბიტს გადააქცევს 1-ად თუ ორი ბიტიდან 1 ბიტის მნიშვნელობა 1-ია, ან ორივეს მნიშვნელობა 1-ია
`^`	XOR	ბიტს გადააქცევს 1-ად თუ ორი ბიტიდან მხოლოდ ერთ-ერთის მნიშვნელობაა 1
`~`	NOT	შეაბრუნებს ბიტს 0-ს 1-ად და პირიქით
`<<`	Zero fill left shift	ბიტებს წააჩოჩებს მარჯვნიდან მარცხნივ და მიამატებს შესაბამისი რაოდენობის 0-ს
`>>`	Signed right shift	ბიტებს წააჩოჩებს მარცხნიდან მარჯვნივ და მიამატებს უკიდურესი მარცხენა ბიტის მნიშვნელობას
`>>>`	Zero fill right shift	ბიტებს წააჩოჩებს მარცხნიდან მარჯვნივ და მიამატებს 1-ს

ქვემოთ შევეცდები მაქსიმალურად გასაგებად ავხსნა თუ როგორ მუშაობს თითული ოპერატორი ჯავაკსრიპტში პრაქტიკული მაგალითების გამოყენებით.

მოცემული მაგალითისთვის გამოვიყენოთ 2 მარტივი რიცხვი ათობითი სისტემიდან ესენია 5 და 1.

პ.ს. არ დაგვავიწყდეს, რომ ეს რიცხვები ათობითი სისტემიდანაა და ჯერ არ დაგვიკოვერტირებია ორობითში.

როგორც ზემოთ ავღნიშნეთ ჯავასკრიპტი ოპერაციებისთვის იყენებს 32 ბიტს, სადემონსტრაციოთ მაგალითებში გამოვიყენებთ 8 ბიტიან სისტემას ნაცვლად 32-ისა.

ქვემოთ მოცემულ ცხრილებში წარმოდგენილია 32-ბიტიდან ბოლო 8 ბიტი ანუ:

0000 0000 0000 0000 0000 0000 0000 0101

ორობითში კოვერტაცია

მას შემდეგ, რაც რიცხვებს 5-ს და 1-ს დავაკონვერტირებთ ორობით სისტემაში, რომელიც გამოსახული გვექნება 8 ბიტით, მათი მნიშვნელობები იქნება შემდეგი:

ათობითი	5	1
ორობითი	0000000101	000000001

Bitwise ოპერატორი AND (და)

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (5&1) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	1	1
1-ის ორობითი მნიშვნელობა	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 1	0	1

Bitwise ოპერატორი OR (ან)

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (5 | 1) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	1	1
1-ის ორობითი მნიშვნელობა	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 5	1	1

Bitwise ოპერატორი XOR

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (5 ^ 1) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	1	1
1-ის ორობითი მნიშვნელობა	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 4	1	0

Bitwise ოპერატორი NOT

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (~5) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	0	0	0	0	0	1	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება -6	1	1	1	1	1	0	1	0

Bitwise ოპერატორი << (Zero fill left shift)

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (5<<1) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	0	1	0	1
1-ის ორობითი მნიშვნელობა	0	0	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 10	1	0	1	0

როგორც ცხრილში მოყვანილ მაგალითში ჩანს, ორობით კოდს უკიდურესი მარჯვენა მხრიდან მიემატა 0 ხოლო უკიდურესი მარცხნიდან მოაკლდა 0

// 0000 0101 = 5 ათობით სისტემაში
// (*)0000 101(0) = 10 ათობით სისტემაში

Bitwise ოპერატორი >> (Signed right shift)

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (5>>1) და გამოვსახოთ ის ცხრილის სახით.

5-ის ორობითი მნიშვნელობა	1	0	1
1-ის ორობითი მნიშვნელობა	0	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 2	0	1	0

ცხრილში მოყვანილი მაგალითიდან ვხედავთ, რომ ორობითი კოდის უკიდურეს მარცხენა მხარეს დაემატა 0 ხოლო უკიდურესმა მარცხენა მხარემ წაიჩოჩა მარჯვნივ და არსებული 1 ამოვარდა სისტემიდან

// 0000 0101 = 5 ათობით სისტემაში
// (0)000 10(*) = 2 ათობით სისტემაში

მოცემული ოპერატორი განსხვავებულად იქცევა უარყოფითი რიცხვების შემთხვევაში მოდი მაგალითისთვის მოვიყვანოთ შემდეგი შედარება (-5>>1) ამ რიცხვის

-5-ის ორობითი მნიშვნელობა	1	1	1	1	1	0	1	1
1-ის ორობითი მნიშვნელობა	0	0	0	0	0	0	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება -3	1	1	1	1	1	1	0	1

იმ შემთხვევაში თუ უკიდურეს მარცხენა ჩანაწერში გვაქვს 1 ჩაემატება 1, წინააღმდეგ შემთხვევაში 0

// 1111 1011 = -5 ათობით სისტემაში
// (1)111 101(*) = -3 ათობით სისტემაში

Bitwise ოპერატორი >>> (Zero fill right shift)

მაგალითისთვის გამოვიყენოთ შემდეგი ლოგიკური ოპერატორი (-5>>>1) და გამოვსახოთ ის ცხრილის სახით.

მოცემული ოპერატორი ზუსტად იგივენაირად იქცევა როგორც >> ოპერატორი, მაგრამ აქვს 1 განხსვავება, რომელიც შეეხება უარყოფით რიცხვებს.

ანუ ნებისმიერ შემთხვევაში მარცხნიდან ამატებს 0-ს ხოლო მარჯვნიდან ჩააჩოჩებს შესაბამისი რაოდენობის ბიტით

-5-ის ორობითი მნიშვნელობა	1	1	1	…	1	1	0	1	1
1-ის ორობითი მნიშვნელობა	0	0	0	…	0	0	0	0	1
მიღებული მნიშვნელობა 10-ობით სისტემაში იქნება 2147483645	0	1	1	…	1	1	1	0	1