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
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 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: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();
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()
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"}
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.
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 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 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 .
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.
the Symbol data type is a primitive type introduced in ES6 (ECMAScript 2015). It is used to create unique identifiers for objects. Symbol with Description: const sym = Symbol('mySymbol'); console.log(sym); // Symbol(mySymbol) console.log(sym.description); // mySymbol
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
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
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 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
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...
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
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: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
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 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😊
After long time so exiting 🎉 please just keep this playlist regular
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();
36:12 bhaiya samajh me aa gaya. Thankyou for the video .🙏🏻🙏🏻 Lots of Love❤❤
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()
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"}
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.
Bhaiya bohot ache se samj me aaya.. Please consistent raho...
33:03 - Symbols are immutable (cannot be changed) datatype and are unique. A value of this type can be created using Symbol():
🩲
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
36:12 Bhaiya smj mei aagya 🙏
Bhaiya samajh aa gaya, thenks for the amazing content..
thanks bhai samajh aya sb or ap bohat acha teach krty ho love your vedios
Bhaiya Samag me aa gya ( jindagi mepahi bar samagh me aa rhaa he aapke pdhaneketarikese lots of love love bhai)
bhaiya aa gaya samaj bahut aacha lec tha
BASICS IS CLEARED NOW MOVING TO THE NEXT INE THANK YOU SIR FOR FREE COURSE GOD BLESS YOU
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
Bhaiya samaj maa aa gaya jo app na padhaya hai ajj lecture ma thank you
Bhaiya samajh me aaa.... gaya🤩🤩🤩🤩🤩
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.
Bhaiya samajh mein aa gaya thank you
Bhaiya samjh me aagya hai sab, bhot shukriya aapka sir🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
31:36 marks is of number type to convert into big int we have write n at the end of number value
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...
Thank you! Bhaiya samajh me aa gaya .
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 .
bhaiya jitna padhaya sab samajh me aa gaya
32:50
Symbols add "hidden" properties to objects
apki vajha se mujhe bahut help milti hai thank you sir
bhaiya samjh aagya h...................please bring the consistency
Samajh aa gaya bhaiya, dosto go for it is good infinity
bhaiya smjh m aagya👍👍😇😇
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.
explanation is very good sir
the Symbol data type is a primitive type introduced in ES6 (ECMAScript 2015). It is used to create unique identifiers for objects.
Symbol with Description:
const sym = Symbol('mySymbol');
console.log(sym); // Symbol(mySymbol)
console.log(sym.description); // mySymbol
lovely explanation, aaj samajh aaya var, let and const. Thank you so much for sharing with us your valuable experties.
Bhaiya samajh mai aa gya.
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
Bhaiya Samaz mein aagya 🔥🔥
best sir of coding 🥰😍😇😇😇😇😇😇😇
bhaiya end level ka concept mil gya hay love u
Bhaiya samajh aa gya. Mazda aa gya!!!
Samajh me aa gaya bhaiya ♥
bhauya samhj mei aa gaya 😍😍
Samajh me aa gaya Bhaiya
Symbol is a primitive datatype used to create unique identifiers in JS.Please complete the playlist bhaiya ..please maintain the consistency 🙏🙏
bahut badiya bhaiya
Concept clear ! Samajh me aa gya
18:16 rivising point
Bhaiiyaa samaj aa gaya❤
Bhaiyya samajh me a gaya jo apne padhaya 😊
your video give me lots of confidence to do coding.
Samajh aa gaya bhaiya ❤❤❤❤
Bhaiya samajh me bhi aa gya aur Mzaa bhi aa gya ..😍😍
All clear bhaiya❤
Sir samaj me aa Gaya ❤❤, sir javascript series countinue chalu rakho 🙏🙏
thank you sir , understood!!
bhaiya samaj me aya gya thanks
Bhaiya samjh me a agye
Thankuuu❤❤❤❤
bhaiya achhesae samjh aa gaya
bhaiya samjh aa gya... Top Notch Content ...
thank you bhaiyaa
console.log("samaj me aa gya bhaiya");
♥♥♥♥
bhaiya samjh aa gya jo aap padha rhe ho ❤
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
samajh me agaya.😀😀😀
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
samajh me aa gaya, thank you bhaiya
Bhaiya samajh me aagaya, thank you
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
Amazing very well
Bhaiya Samj me agaya 😃
Very good lecture
Babbar bhagwan of coding duniya 😊 I love you bhaiya ❤
bhaiya samaj mai aa gaya hai. love you bhaiya❤
Thank you bhaiya, clear ho gaya topic
this course is very help full💗💗💗💗💗 love you bro
bhaiya samajh aa gya thank you
Thank you bhaiya pls complete kar dena series
I Understood your explanation.
Babbar bhaiya 3month ke baad 😮😮😮 please continue please 🥺
Bhaiya smjh m aagya..
bhaiya samjh main aaga 😇
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...
superb!!!
Bhaiya smj aa gya 🎉
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.
THANK U VERY MUCH SIR
excellent work!
concept is clear!❤❤❤
badhiya tha guru
Very nice sir ❤
Thanks java script series start karne ke liye 😊
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
Bhaiya samajh me aagya.
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.
Symbol data type - It is used to identify the object properties.
Syntax = symbol ([description] )
Thank you for the Amazing Content.