32:50 Symbol-> primitive data type -> introduced in ES6 -> used to represent unique values, that can be used as keys for objects PROS-> Being both unique and immutable, serve effectively as distinctive identifiers within objects and classes -> They enable the creation of private properties and methods within classes, enhancing encapsulation and security -> Are advantageous for establishing constants that are easily shared across various segments of your codebase CONS-> limited usability -> complex debugging For example, const value1 = Symbol('hi'); const value2 = Symbol('hi'); console.log(value1 === value2); // false
Thank you bhaiya, for this amazing lecture. JavaScript Symbols are a new type of primitive data type introduced in the ES6 version of the language. They are used to represent unique values that can be used as identifiers or keys in objects. They are also used to create private properties and methods in classes. Example- // Create a Symbol const creatingSymbol = Symbol(); console.log( creatingSymbol ); // expected output: Symbol()
Symbols are unique and immutable data types that can be used as unique identifiers. They are often used as property keys in objects to avoid naming collisions.
- symbols are a primitive data type introduced in ECMAScript 6 - A symbol is a unique and immutable data type that can be used as an identifier for object properties. - const answer = Symbol(); Pros: Uniqueness Privacy and Encapsulation Well-Suited for Special Use Cases Cons: Obscure Syntax Limited Browser Support Memory Consumption
The Symbol data type represents a unique and immutable primitive value. It is used to create a unique property keys for objects ensuring they won't conflict with existing string or number keys that you define in your code. ex: const sym1 = symbol() ; const sym2 = symbol("Hello"); it creates a unique symbol for above sym1 and sym2.
Symbol is a Primitive datatype. Introduced in ES6. You can think about it like this: Symbol is a built in object whose constructor [symbol()] returns a Symbol which is guaranteed to be unique. Ex: - let x = Symbol("hello"); here Symbol("hello") returns a unique and immutable value for the x. let y = Symbol("hello"); here also returns a unique (other than that assigned to x above) and immutable value for the y. console.log(x == y); // false console.log(x === y); // false
Symbols in JavaScript are unique immutable data types introduced in ECMAScript 6. They're created using the Symbol() function and used for unique identifiers, preventing naming collisions. Symbols are often used to define object properties inaccessible to regular JavaScript code, useful for creating private properties or special behaviors. Samjh mai aa gya sir . Thanku sir for this Full stack playlist .
Symbols are typically immutable and can be more memory-efficient than strings, especially when used as keys in data structures like hashes or dictionaries. const mySymbol = Symbol('description'); // A symbol in JavaScript const myObject = { [mySymbol]: 'value' };
In JavaScript, symbols are a primitive data type introduced in ECMAScript 2015 (ES6) to represent unique identifiers. Symbols are created with the Symbol() function, which optionally takes a string as an argument that serves as a description of the symbol. The key characteristics of symbols include: Uniqueness, Immutabililty and Privacy.
Symbol is a primitive data-type. It is basically an object whose constructor returns an unique symbol each time it is called. This is used to provide unique property keys and it also provides a weak form of encapsulation/information-hiding
Symbol is a built-in object whose constructor returns a symbol primitive - also called a Symbol value or just a Symbol - that's guaranteed to be unique. Symbols are often used to add unique property keys to an object that won't collide with keys any other code might add to the object, and which are hidden from any mechanisms other code will typically use to access the object. That enables a form of weak encapsulation, or a weak form of information hiding. const sym1 = Symbol(); const sym2 = Symbol("foo"); const sym3 = Symbol("foo"); The above code creates three new Symbols. Note that Symbol("foo") does not coerce the string "foo" into a Symbol.
syntax const sym2 = Symbol("Love"); - symbols are a primitive data type introduced in ECMAScript 6 - A symbol is a unique and immutable data type that can be used as an identifier for object properties. - const answer = Symbol(); Pros: Uniqueness Privacy and Encapsulation Well-Suited for Special Use Cases Cons: Obscure Syntax Limited Browser Support Memory Consumption
32:50 In JavaScript, the symbol data type is a primitive data type introduced in ECMAScript 6 (ES6) to represent unique identifiers. Symbols are immutable and unique, meaning that each symbol value is distinct and cannot be changed. // Creating a symbol const mySymbol = Symbol(); // Symbols are unique const anotherSymbol = Symbol(); console.log(mySymbol === anotherSymbol); // Output: false We create symbols using the Symbol() function. Each call to Symbol() returns a new, unique symbol value. Symbols can also have optional descriptions, which can help with debugging and identifying symbols.
The JavaScript Symbol is a primitive data type, just like Number, String, Boolean, etc. It represents a unique identifier and can be used in various ways. Symbols are used to create object properties, for example, when you want to assign a unique identifier to an object.
Symbol Data Type-> primitive data type -> introduced in ES6 -> used to represent unique values, that can be used as keys for objects PROS-> Being both unique and immutable, serve effectively as distinctive identifiers within objects and classes -> They enable the creation of private properties and methods within classes, enhancing encapsulation and security -> Are advantageous for establishing constants that are easily shared across various segments of your codebase CONS-> limited usability -> complex debugging for ex:- const value1 = Symbol('Namaste Dunia'); const value2 = Symbol('Namaste Dunia'); console.log(value1 === value2); //Output:- false
00:06 Variables are named memory locations for storing different data types. 02:08 Storing values in memory requires understanding and accessing their addresses. 05:51 Variables in JavaScript are named memory locations for storing data. 07:48 Global scope variables in JavaScript 11:48 ES6 introduces let and const to solve variable scope issues. 13:55 Understanding blocked scope and redefinition in JavaScript 18:06 Understand variable declaration and manipulation in JavaScript 19:45 Naming rules for JavaScript variables 23:28 Understanding different data types in JavaScript 25:17 JavaScript provides various primitive data types 28:55 JavaScript allows dynamic typing with variables supporting different data types 30:29 Discussion on big integer numbers in JavaScript 33:49 Variables and naming conventions in JavaScript 35:21 The batch for studying DS is starting on 25th April for a duration of 4.5 months.
symbols are unique and immutable data types often used as property keys in objects. They're useful for creating private properties and avoiding naming collisions in object properties or keys. Symbols also play a role in defining well-known symbols, such as Symbol.iterator, which enables custom objects to be iterable.
JavaScript Symbols are a new type of primitive data type introduced in the ES6 version of the language. They are used to represent unique values that can be used as identifiers or keys in objects. They are also used to create private properties and methods in classes.Symbols are immutable (cannot be changed) and are unique.
32:48 Definiton of Symbol Data Type. Primitive data types are those data types which stores single values, are immutable, cannot be shared, do not have methods, and have default values when not assigned. Symbols are primitive data types. Symbols are introduced in ES6. Symbols return unique identifiers that can be used to add unique property keys to an object that won’t collide with keys of any other code that might add to the object. They are used as object properties that cannot be recreated. If symbols doesn't exist in JS it is difficult for us to create unique keys with help primitive data types in this language. Symbols are often used as keys for object properties when you want to avoid naming conflicts with other properties. Example.. const key1 = Symbol('identifier for key1'); const key2 = Symbol('identifier for key2'); myObj = {}; myObj[key1] = "Love"; myObj[key2] = "Babbar"; console.log(myObj[key1]); // Love (Ans) console.log(myObj[key2]); // Babbar (Ans) console.log(myObj.k1); //error console.log(myObj); // {Symbol(): "Love", Symbol(): "Babbar"}
Symbols in JavaScript are unique and immutable values, often used as property keys to prevent naming collisions and define special behaviors, like built-in methods or private object members
Bhadiya cheeze hove h symbol, ba kau constructor ekdam unique value bheje h , ekdam sat pratishat unique, tum use kar sake ho ikaa key generate karan vaaste Phaar egjaampil Symbol(hello) === Symbol(hello) devat hai phalse
32:00 JavaScript mein "symbol" ek primitive data type hai, jo ES6 (ECMAScript 2015) mein introduce kiya gaya tha. Symbol ek unique aur immutable data type hai. Har ek symbol unique hota hai aur kabhi bhi do symbols equal (===) nahi hote hain, chahe woh do alag-alag symbol instances hi kyun na hon. Symbols unique identifiers provide karte hain, jisse aapko kisi property ko unique taur par identify karne mein madad milti hai. Yeh property names ke clashes ko rokne mein helpful hota hai, jaise ki object literals mein. Symbol ko create karne ke liye Symbol() function ka use hota hai: ex- const mySymbol = Symbol();
32:50 What is Symbol data type----- A Symbol is a primitive data type introduced in ECMAScript 2015 (ES6). It is created using the Symbol() function. Each time Symbol() is called, a new and unique Symbol value is returned. @codehelp @lovebabber
* Symbol is a primitive datatype , introduced in ES6. * It is used to represent unique identifiers and avoid naming collisions. * These are not enumerable i.e. we cannot iterate loops over them. * Pros --> 1. it provides uniqueness 2. avoid name conflicts 3. global symbol registry ex-Symbol.for() * Cons --> 1. debugging is hard when dealing with complex objects 2. sometimes it may lead to confusions 3. introducing Symbols to an API is a complicated task
Symbols are immutable (unchangeable) and unique values in JavaScript. They are created using the Symbol() function. Example: const mySymbol = Symbol("Hello"); Hello is the description of the symbol. PROS => 1.) Uniqueness: Symbols are always unique, preventing naming clashes. 2.) Immutable: Once created, symbols cannot be changed. 3.) Private Properties: Symbols can be used for private object properties. 4.) Avoid Duplication: When sharing code snippets across programs, symbols help avoid duplication issues. 5.) Global Registry: Symbols can be shared globally using Symbol.for(). CONS => 1.) No Literal Representation: Unlike strings or numbers, symbols have no literal value. 2.) Not Iterable: Symbols are not included in for...in loops. 3.) Limited Use Cases: Symbols are mainly useful for specific scenarios like object properties and avoiding duplication.
Nice Session Love Bhaiya... Symbols is a primitive data type. Symbols are used to represent unique values that used as keys for objects. Lets Continue...
i left your dsa series and got a back log but now .its not gonna happen , as soon as you post the next video i will watch and take notes will be consistent like you are . A BIG THANKYOY LOVE BABBAR BHAIYA
HOME-WORK ANSWER; symbol datatype : They are unique and immutable data types, meaning that every symbol value created using the Symbol() function is unique
Bhaiya apse padh kar maza aa rha but ek miskte apse yah hui hh ki variable naming convention jab aa padha rahe hh toh use mai apne kuch rules batye the but ek galti hh ki can't start with number but apne bola hh can start with number. Baki sab tk hh aur mazza bhi aa rha apse padh kar... ❤❤Love u Bhaiya plzz reply kariye ga
32:50 Symbol-> primitive data type
-> introduced in ES6
-> used to represent unique values, that can be used as keys for objects
PROS-> Being both unique and immutable, serve effectively as distinctive identifiers within objects and classes
-> They enable the creation of private properties and methods within classes, enhancing encapsulation and security
-> Are advantageous for establishing constants that are easily shared across various segments of your codebase
CONS-> limited usability
-> complex debugging
For example,
const value1 = Symbol('hi');
const value2 = Symbol('hi');
console.log(value1 === value2); // false
how false ?
@@tarunpatil001 cause they are symbols. Symbols are unique and immutable data types that can be used as unique identifiers
Best mentor in the world of web development ..doing great job.keep continue your efforts .
yes
Thank you bhaiya, for this amazing lecture.
JavaScript Symbols are a new type of primitive data type introduced in the ES6 version of the language. They are used to represent unique values that can be used as identifiers or keys in objects. They are also used to create private properties and methods in classes.
Example- // Create a Symbol
const creatingSymbol = Symbol();
console.log( creatingSymbol );
// expected output: Symbol()
Symbols are unique and immutable data types that can be used as unique identifiers. They are often used as property keys in objects to avoid naming collisions.
- symbols are a primitive data type introduced in ECMAScript 6
- A symbol is a unique and immutable data type that can be used as an identifier for object properties.
- const answer = Symbol();
Pros:
Uniqueness
Privacy and Encapsulation
Well-Suited for Special Use Cases
Cons:
Obscure Syntax
Limited Browser Support
Memory Consumption
Thaku brother😊
The Symbol data type represents a unique and immutable primitive value. It is used to create a unique property keys for objects ensuring they won't conflict with existing string or number keys that you define in your code.
ex:
const sym1 = symbol() ;
const sym2 = symbol("Hello");
it creates a unique symbol for above sym1 and sym2.
After long time so exiting 🎉 please just keep this playlist regular
Symbol is a Primitive datatype.
Introduced in ES6.
You can think about it like this: Symbol is a built in object whose constructor [symbol()] returns a Symbol which is guaranteed to be unique.
Ex: -
let x = Symbol("hello");
here Symbol("hello") returns a unique and immutable value for the x.
let y = Symbol("hello");
here also returns a unique (other than that assigned to x above) and immutable value for the y.
console.log(x == y); // false
console.log(x === y); // false
BASICS IS CLEARED NOW MOVING TO THE NEXT INE THANK YOU SIR FOR FREE COURSE GOD BLESS YOU
Symbols in JavaScript are unique immutable data types introduced in ECMAScript 6. They're created using the Symbol() function and used for unique identifiers, preventing naming collisions. Symbols are often used to define object properties inaccessible to regular JavaScript code, useful for creating private properties or special behaviors.
Samjh mai aa gya sir .
Thanku sir for this Full stack playlist .
33:03 - Symbols are immutable (cannot be changed) datatype and are unique. A value of this type can be created using Symbol():
🩲
Symbols are typically immutable and can be more memory-efficient than strings, especially when used as keys in data structures like hashes or dictionaries.
const mySymbol = Symbol('description'); // A symbol in JavaScript
const myObject = {
[mySymbol]: 'value'
};
Bhaiya Please keep continue this series, it is the only one free youtube series, which is this much extended and in depth in entire youtube
In JavaScript, symbols are a primitive data type introduced in ECMAScript 2015 (ES6) to represent unique identifiers. Symbols are created with the Symbol() function, which optionally takes a string as an argument that serves as a description of the symbol.
The key characteristics of symbols include: Uniqueness, Immutabililty and Privacy.
Symbol is a primitive datatype used to create unique identifiers in JS.Please complete the playlist bhaiya ..please maintain the consistency 🙏🙏
Symbol is a primitive data-type. It is basically an object whose constructor returns an unique symbol each time it is called. This is used to provide unique property keys and it also provides a weak form of encapsulation/information-hiding
Symbol data type - It is used to identify the object properties.
Syntax = symbol ([description] )
Symbol is a built-in object whose constructor returns a symbol primitive - also called a Symbol value or just a Symbol - that's guaranteed to be unique. Symbols are often used to add unique property keys to an object that won't collide with keys any other code might add to the object, and which are hidden from any mechanisms other code will typically use to access the object. That enables a form of weak encapsulation, or a weak form of information hiding.
const sym1 = Symbol();
const sym2 = Symbol("foo");
const sym3 = Symbol("foo");
The above code creates three new Symbols. Note that Symbol("foo") does not coerce the string "foo" into a Symbol.
Bhaiya samjh me aagya hai sab, bhot shukriya aapka sir🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
36:12 bhaiya samajh me aa gaya. Thankyou for the video .🙏🏻🙏🏻 Lots of Love❤❤
syntax
const sym2 = Symbol("Love");
- symbols are a primitive data type introduced in ECMAScript 6
- A symbol is a unique and immutable data type that can be used as an identifier for object properties.
- const answer = Symbol();
Pros:
Uniqueness
Privacy and Encapsulation
Well-Suited for Special Use Cases
Cons:
Obscure Syntax
Limited Browser Support
Memory Consumption
32:50
In JavaScript, the symbol data type is a primitive data type introduced in ECMAScript 6 (ES6) to represent unique identifiers. Symbols are immutable and unique, meaning that each symbol value is distinct and cannot be changed.
// Creating a symbol
const mySymbol = Symbol();
// Symbols are unique
const anotherSymbol = Symbol();
console.log(mySymbol === anotherSymbol); // Output: false
We create symbols using the Symbol() function. Each call to Symbol() returns a new, unique symbol value.
Symbols can also have optional descriptions, which can help with debugging and identifying symbols.
The JavaScript Symbol is a primitive data type, just like Number, String, Boolean, etc. It represents a unique identifier and can be used in various ways. Symbols are used to create object properties, for example, when you want to assign a unique identifier to an object.
Symbol Data Type-> primitive data type
-> introduced in ES6
-> used to represent unique values, that can be used as keys for objects
PROS-> Being both unique and immutable, serve effectively as distinctive identifiers within objects and classes
-> They enable the creation of private properties and methods within classes, enhancing encapsulation and security
-> Are advantageous for establishing constants that are easily shared across various segments of your codebase
CONS-> limited usability
-> complex debugging
for ex:-
const value1 = Symbol('Namaste Dunia');
const value2 = Symbol('Namaste Dunia');
console.log(value1 === value2); //Output:- false
Bhaiya bohot ache se samj me aaya.. Please consistent raho...
00:06 Variables are named memory locations for storing different data types.
02:08 Storing values in memory requires understanding and accessing their addresses.
05:51 Variables in JavaScript are named memory locations for storing data.
07:48 Global scope variables in JavaScript
11:48 ES6 introduces let and const to solve variable scope issues.
13:55 Understanding blocked scope and redefinition in JavaScript
18:06 Understand variable declaration and manipulation in JavaScript
19:45 Naming rules for JavaScript variables
23:28 Understanding different data types in JavaScript
25:17 JavaScript provides various primitive data types
28:55 JavaScript allows dynamic typing with variables supporting different data types
30:29 Discussion on big integer numbers in JavaScript
33:49 Variables and naming conventions in JavaScript
35:21 The batch for studying DS is starting on 25th April for a duration of 4.5 months.
thanks bhai samajh aya sb or ap bohat acha teach krty ho love your vedios
symbols are unique and immutable data types often used as property keys in objects. They're useful for creating private properties and avoiding naming collisions in object properties or keys. Symbols also play a role in defining well-known symbols, such as Symbol.iterator, which enables custom objects to be iterable.
JavaScript Symbols are a new type of primitive data type introduced in the ES6 version of the language. They are used to represent unique values that can be used as identifiers or keys in objects. They are also used to create private properties and methods in classes.Symbols are immutable (cannot be changed) and are unique.
32:48 Definiton of Symbol Data Type.
Primitive data types are those data types which stores single values, are immutable, cannot be shared, do not have methods, and have default values when not assigned.
Symbols are primitive data types.
Symbols are introduced in ES6.
Symbols return unique identifiers that can be used to add unique property keys to an object that won’t collide with keys of any other code that might add to the object. They are used as object properties that cannot be recreated.
If symbols doesn't exist in JS it is difficult for us to create unique keys with help primitive data types in this language.
Symbols are often used as keys for object properties when you want to avoid naming conflicts with other properties.
Example..
const key1 = Symbol('identifier for key1');
const key2 = Symbol('identifier for key2');
myObj = {};
myObj[key1] = "Love";
myObj[key2] = "Babbar";
console.log(myObj[key1]); // Love (Ans)
console.log(myObj[key2]); // Babbar (Ans)
console.log(myObj.k1); //error
console.log(myObj); // {Symbol(): "Love", Symbol(): "Babbar"}
Symbole data types is like number, string, boolean symbole are used to create object properties when you want to assign unique identifier to an object
Symbols in JavaScript are unique and immutable values, often used as property keys to prevent naming collisions and define special behaviors, like built-in methods or private object members
symbol is a data type of primitive data type. The Symbol() function returns the symbol value type. The value returned from Symbol() is unique
Bhadiya cheeze hove h symbol, ba kau constructor ekdam unique value bheje h , ekdam sat pratishat unique, tum use kar sake ho ikaa key generate karan vaaste
Phaar egjaampil
Symbol(hello) === Symbol(hello) devat hai phalse
apki vajha se mujhe bahut help milti hai thank you sir
32:00
JavaScript mein "symbol" ek primitive data type hai, jo ES6 (ECMAScript 2015) mein introduce kiya gaya tha. Symbol ek unique aur immutable data type hai. Har ek symbol unique hota hai aur kabhi bhi do symbols equal (===) nahi hote hain, chahe woh do alag-alag symbol instances hi kyun na hon.
Symbols unique identifiers provide karte hain, jisse aapko kisi property ko unique taur par identify karne mein madad milti hai. Yeh property names ke clashes ko rokne mein helpful hota hai, jaise ki object literals mein.
Symbol ko create karne ke liye Symbol() function ka use hota hai:
ex-
const mySymbol = Symbol();
sir i'm from nepal and i have studied from your couse and i love your couse.
Thank you soo much dil se .
Thanks You bhaiya>>> you cleared all my doubts...
lovely explanation, aaj samajh aaya var, let and const. Thank you so much for sharing with us your valuable experties.
32:50
Symbols add "hidden" properties to objects
32:50
What is Symbol data type----- A Symbol is a primitive data type introduced in ECMAScript 2015 (ES6). It is created using the Symbol() function. Each time Symbol() is called, a new and unique Symbol value is returned.
@codehelp @lovebabber
* Symbol is a primitive datatype , introduced in ES6.
* It is used to represent unique identifiers and avoid naming collisions.
* These are not enumerable i.e. we cannot iterate loops over them.
* Pros --> 1. it provides uniqueness
2. avoid name conflicts
3. global symbol registry ex-Symbol.for()
* Cons --> 1. debugging is hard when dealing with complex objects
2. sometimes it may lead to confusions
3. introducing Symbols to an API is a complicated task
your video give me lots of confidence to do coding.
Symbol is used to represent unique values that can be used as identifiers or keys in objects.
Bhaiya Samag me aa gya ( jindagi mepahi bar samagh me aa rhaa he aapke pdhaneketarikese lots of love love bhai)
Symbols are immutable (unchangeable) and unique values in JavaScript. They are created using the Symbol() function.
Example: const mySymbol = Symbol("Hello");
Hello is the description of the symbol.
PROS => 1.) Uniqueness: Symbols are always unique, preventing naming clashes.
2.) Immutable: Once created, symbols cannot be changed.
3.) Private Properties: Symbols can be used for private object properties.
4.) Avoid Duplication: When sharing code snippets across programs, symbols help avoid duplication issues.
5.) Global Registry: Symbols can be shared globally using Symbol.for().
CONS => 1.) No Literal Representation: Unlike strings or numbers, symbols have no literal value.
2.) Not Iterable: Symbols are not included in for...in loops.
3.) Limited Use Cases: Symbols are mainly useful for specific scenarios like object properties and avoiding duplication.
31:36 marks is of number type to convert into big int we have write n at the end of number value
Nice Session Love Bhaiya...
Symbols is a primitive data type.
Symbols are used to represent unique values that used as keys for objects.
Lets Continue...
i left your dsa series and got a back log but now .its not gonna happen , as soon as you post the next video i will watch and take notes will be consistent like you are . A BIG THANKYOY LOVE BABBAR BHAIYA
understood
Symbols: It is new type of primitive data type which are used to represent unique values that can be used as identifiers or keys in objects.
Very nice sir ❤
Thanks java script series start karne ke liye 😊
HOME-WORK ANSWER;
symbol datatype :
They are unique and immutable data types, meaning that every symbol value created using the Symbol() function is unique
explanation is very good sir
Bhaiya apse padh kar maza aa rha but ek miskte apse yah hui hh ki variable naming convention jab aa padha rahe hh toh use mai apne kuch rules batye the but ek galti hh ki can't start with number but apne bola hh can start with number.
Baki sab tk hh aur mazza bhi aa rha apse padh kar... ❤❤Love u Bhaiya plzz reply kariye ga
Sir samaj me aa Gaya ❤❤, sir javascript series countinue chalu rakho 🙏🙏
36:12 Bhaiya smj mei aagya 🙏
Bhaiya samajh me aaa.... gaya🤩🤩🤩🤩🤩
18:16 rivising point
Bhaiya samajh me bhi aa gya aur Mzaa bhi aa gya ..😍😍
1like = Marks
bahut badiya bhaiya
Samajh me aa gaya Bhaiya
bhaiya samjh me aagya
Bhaiyya samajh me a gaya jo apne padhaya 😊
Samajh aa gaya bhaiya, dosto go for it is good infinity
Symbol is a primitive data type which is used to represent a unique value
thank you bhaiyaa
console.log("samaj me aa gya bhaiya");
♥♥♥♥
Thanku you so much bhaiya for Javascript series. Please continue the series❤❤
Bhaiya Samaz mein aagya 🔥🔥
Very good lecture
samajh me aa gaya, thank you bhaiya
thank you sir , understood!!
Bhaiya samajh aa gya. Mazda aa gya!!!
Anxiously waiting for the videos❤
Best CS content creator on RUclips
Love from pakistan🇵🇰
Concept clear ! Samajh me aa gya
bhaiya end level ka concept mil gya hay love u
excellent work!
concept is clear!❤❤❤
Amazing very well
Thank you bhaiya pls complete kar dena series
Samajh me aa gaya bhaiya ♥
Thank you bhaiya, clear ho gaya topic
Bhaiya samajh me aagaya, thank you
bhaiya samajh aa gya thank you
bhaiya samjh aagya h...................please bring the consistency
this course is very help full💗💗💗💗💗 love you bro
Bhaiya samjh me a agye
Thankuuu❤❤❤❤
sir symbol is a primitive data type , it is immutable data type that used to identifier for a symbol
Thank you for the Amazing Content.
All clear bhaiya❤
bhaiya samajh me aa gya
Bhaiya samajh me aagya.
Babbar bhagwan of coding duniya 😊 I love you bhaiya ❤
Samajh aa gaya bhaiya ❤❤❤❤
bhaiya samjh aa gya jo aap padha rhe ho ❤
Bhaiiyaa samaj aa gaya❤
Bhaiya smjh m aagya..
Babbar bhaiya 3month ke baad 😮😮😮 please continue please 🥺
A symbol is a unique and immutable primitive value and may be used as the key of an object property.
Bhaiya smj m aa gya