Return type of variables in JavaScript 1) Primitive Datatypes Number => number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint 2) Non-primitive Datatypes Arrays => object Function => function Object => object
JavaScript is a dynamically typed language. This means that variable types are determined at runtime, and you do not need to explicitly declare the type of a variable before using it. You can assign different types of values to a variable during its lifetime. For example, in JavaScript, you can do the following: let x = 10; // x is now a number x = "Hello"; // x is now a string x = true; // x is now a boolean On the other hand, statically typed languages require you to declare the variable's type explicitly, and the type checking is done at compile-time, before the code is executed. Languages like Java, C++, and TypeScript are statically typed, and they require you to specify the variable type explicitly when declaring them: int x = 10; // x is a variable of type int String name = "John"; // name is a variable of type String JavaScript's dynamic typing allows for more flexibility but can lead to potential runtime errors if not handled carefully. Static typing, on the other hand, provides better type safety at the cost of some initial verbosity and strictness.
Primitive DataTypes: 1.Number: Represents both integer and floating-point numbers. Example: 5, 3.14. 2.String: Represents a sequence of characters enclosed in single or double quotes. Example: "Hello, world!". 3,Boolean: Represents a binary value, either true or false, often used for conditional logic. 4.Undefined: Represents a variable that has been declared but hasn't been assigned a value yet. Example: let x;. 5.Null: standalone value it is represenataion of empty value it is special type and it is a object type. Example: let y = null; 6.Symbol (ES6): it is mostly used used to find uniqnece. 7.BigInt (ES11): Represents large integers that cannot be represented by the Number type. Refence (Object Data Types): 1.Object: Represents a collection of key-value pairs (properties and methods). Example: { name: "John", age: 30 }. 2.Array: Represents a list-like collection of values, indexed by numbers (integer indices). Example: [1, 2, 3, 4]. 3.Function: Represents a reusable block of code that can be invoked or called with arguments. Example: function add(x, y) { return x + y; }. 4.Date: Represents dates and times. 5.RegExp: Represents regular expressions for pattern matching. lets talk about some Range of Primitive DataType: 1.Number: Represents both integers and floating-point numbers. Typical Range: -9,007,199,254,740,992 (-2^53) to 9,007,199,254,740,992 (2^53) inclusive. Smallest Increment: 2^(-52). 2.String: Represents a sequence of characters. No specific range limit, but practical limits depend on memory and system resources. 3.Boolean: Represents true or false. Only two possible values: true and false. 4.Undefined: Represents a variable that has been declared but hasn't been assigned a value. It has only one possible value: undefined. 5.Null: Represents the intentional absence of any object or value. It has only one possible value: null. 6.Symbol (ES6): Represents a unique and immutable value. No specific range limit. 7.BigInt (ES11): Represents large integers that cannot be represented by the Number type. The range is practically unlimited and depends on available memory.
Thank you sir for your guidance and hard work here is your gift * Premitive Datatypes Type typeof i) Number number ii) String string iii) Boolean boolean iv) Bigint bigint v) Symbol symbol vi) Null object vii) Undefined undefined * Non-Premitive OR Referance OR Object datatype Type typeof i) Object object ii) Array object iii) Function function(object) This is my research and output if anythig is wrong please feel proud to reply me Thank you sir
when you say "sirf padhna thode hai, interviews bhi crack karne hain" that thing makes your JS tutorials different and unique from others. Although I am writing this comment in English but I just...can't tell you how much this Hindi tutorials are helping me as well as thousand others #ThankYouHiteshSir❤❤
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them. Thank you sir for your Hard work and guidance ❤
Sir at 14:18, bigNumber ka value isliye undefined aaya kyuki aapne uski declaration ko hi comment kr diya tha 😅 When I tried that declaration myself, it shows the type to bigint 👨💻
@@deepakshukla1810 it was defined, but when sir was commenting out console.logs , in order to provide a cleaner output, he mistakenly commented the declaration of bigNumber.
Type and typeof return value number - number string - String boolean - boolean symbol - symbol bigint - bigint undefined - undefined null - object array - object object - object function - function
Sir When you said this "sirf padhna thode hai, interviews bhi crack karne hain" hits different and motivate to learn from you. #thankyouhiteshsir for making such valuable Javascript course playlist
There are two categories of data types: 1)Primitive: These are call-by-value. The types of primitive data types include String, Number, Boolean, Null, Undefined, Symbol, and BigInt. Note that Symbols uniquely identify variables, even if two variables have the same data and data type. Primitive variables datatype is same but null datatype is object 2) Non-primitive: These are call-by-reference. The types of non-primitive data types are Array, Object, and Function. The data type for these is 'object,' but for functions, they return a data type of 'function,' though they also have an object data type.
There are mainly 2 types of datatypes : 1. Primitive ( call by value = copy version ): - string => string - number => number - Boolean => boolean - null => object - undefined => undefined - symbol => symbol - Bigint => Bigint 2. Non-Primitive ( reference type ): - Array => object - Object => object - Function => Object Function 3. JavaScript is "Dynamically typed language" because all type checks are being performed during Runtime .
Primitive Datatypes ka return type String => String Number => Number Boolean => Boolean Null => Object Undefined => Undefined Symbol => Symbol BigInt => BigInt Reference Datatypes ka return type Array => Object Object => Object Function => Function
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them. Return types of variables in js: Primitive datatypes: Number =>number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint Reference (Non primitive data types): Array => object Object => object Function => function
02:16 JavaScript data types can be categorized into primitive and non-primitive types. 04:32 Primitive data types in JavaScript 06:48 JavaScript data types 09:04 JavaScript data types include numbers, booleans, null, and undefined 11:20 Symbol and BigInt data types 13:36 Arrays and objects are non-primitive types in JavaScript 15:52 Using typeof function to find data types of variables 18:02 The return type for all non-primitive types is object function.
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them.
02:16 JavaScript data types can be categorized into primitive and non-primitive types. 04:32 Primitive data types in JavaScript 06:48 JavaScript data types 09:04 JavaScript data types include numbers, booleans, null, and undefined 11:20 Symbol and BigInt data types 13:36 Arrays and objects are non-primitive types in JavaScript 15:52 Using typeof function to find data types of variables 18:02 The return type for all non-primitive types is object function. Crafted by Merlin AI.
JavaScript is a dynamic language. Because wo do not need to declare its data type. There are two type of Data type 1) Permitve 2) Non Permitve Permitve Data Type Number = Number ; String = String : Boolean = True / False ; symbol => Use to Identify the Components or Variable ; Null => Have NO value ; Undefind => Mean you do not assign a value ; bigInt => Use for big Number ; 2) Non Permitive Array => Array contain a collection of data on different index ; Object => object is a New version of Array. And it contain the data in collect with respect to its Key Point ; Function => Its return type is objectFunction
At 13:57, You commented the variable declaration, that's why the typeof of BigInt value is showing 'undefined' because it couldn't find the variable. The actual typeof value of any BigInt variable is bigint and not undefined.
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them...
for typeof operator:for non primitive datatypes: arr, object:object and for function :object function for primitive datatype: Number => number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint
Javascript is dynamically typed language which means agar program me aage jakar variables ki value ka datatype change hota hai toh Javascript variables ke value ke current datatype ko hi valid manegi. Jo mujhe samaj aaya vo kuch aisa tha.
JavaScript ek "dynamically typed" language hai, yani ki isme variable ki data type runtime (execution time) par decide hoti hai, aur aap ek variable mein alag-alag data types ke values store kar sakte hain. JavaScript mein aap ek variable ko pehle number, phir string, aur phir boolean ke roop mein istemal kar sakte hain, aur interpreter runtime par type checks karta hai.
*********RESULT OF typeof OPERATOR********** 1.PRIMITIVE Number :- number String :- string Boolean :- boolean Bigint :- bigint Undefined :- undefined Null :- object Symbol :- symbol 2.RFERENCE TYPE ( NON PRIMITIVE ) Array :- object Function :- function Object :- object
JavaScript is a dynamically typed language, which means that variables in JavaScript can hold values of any type, and the type of a variable can change at runtime. This flexibility allows for more fluid and adaptable programming, where you don't have to declare the type of a variable explicitly before using it.
dynamically typed language JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them
Data Types : Number > number String > string Boolean > boolean BigInt > bigInt Symbol > symbol null > object ☺☺☺☺☺☺☺ Non Primitive Data type (function, object, Array) > object
JavaScript is a dynamic programming language. Dynamic Typing: Variables in JavaScript are not bound to a specific data type. You can assign a value of any type to a variable, and you can reassign a different type to the same variable without any issues.
JavaScript is a dynamically typed language. In a dynamically typed language like JavaScript, variable types are determined at runtime, not at compile time. This means that you don't have to explicitly declare the data type of a variable when you create it, and you can change the type of a variable by assigning a value of a different type to it during the execution of the program.
Thank you for making such a beautiful javascript tutorial. Because You teach the actual javascript which is necessary for actual production development need. Very Very thank you. I will share your channel as much as possible to everyone. I really like your teaching style and I aslo need that type of javascript teacher. God bless you.
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them. Thank you so much sir for these amazing tutorials 🥰🙌
Return type of variables in Js 1) Primitive Datatype String => string Number => number Boolean => boolean Null => object Undefined => undefined Symbol => symbol BigInt => bigint 2) Non-primitive Datatype Array => object Object => object Function => function
JavaScript is a Dynamically Typed Language. Because data types of the variable are determined by the value they hold at a runtime and it can be changed throughout the program. Primitive data types : String, Number, Boolean, null, undefined, Symbol, BigInt Reference type : Array, Object, Function
String - string Number - number Boolean - boolean Null - object Undefined - undefined BigInt - bigint Symbol - symbol Array - object Function - function Object - object
JavaScript is a dynamic language and not static, which means that variables can hold values of different types during runtime. 2 types of dataTypes 1: Primitive *****7 types of Primitive DataTypes **** 1: Number returns number 2: Boolean returns boolean 3: String returns string 4: undefined returns undefined 5: null returns Object 6: bigint returns Bigint 7: Symbol returns symbol 2: Reference (Non-Primitive) 1: Arrays returns object 2: Function returns function 3: Object returns object
There are 2 data types in Js 1. Primitives 2. Reference (Non Primitives) Primitives: 1. Number Example: let number = 100 2. String Example: let string = "Namaskar" 3. Boolean Example: let isPurchased = false 4. Undefined Example: let subscribe; 5. Null Example: let like = null 6. Symbol Example: const share = ("100") 7. BigInt Example: const number = 100000000000n Reference: 1. Arrays Example: let objectArrays = [1,2,3] 2. Objects Example: let video = { subscribed: true, like: true, share: false } 3. Function Example: function sheryiansStudent() { canMakeAwesomeWebs: true }
Categorisation of data types is on the basis of, how the data is stored in memory and how it is accessed. Primitive is call by value, means if you assign one variable to another then you don't get the reference of data from memory, you get the copy of the value and if you make any changes in second variable it will not change anything in original data. Reference(Non-primitive) here you get the reference of the data from memory and thus refers to same data, if any changes made to data, it will reflect in all the variables referring to it.
// Video 9:- // In this code I explained about primitive and non-primitive datatypes // Primitive datatypes let age=22 let name_2="Harsh" let isEligible=true let temperature=null let accountId=undefined console.log(typeof age); console.log(typeof name_2); console.log(typeof isEligible); console.log(typeof temperature); console.log(typeof accoutId); // Special primitive data type is Symbol const schoolId = Symbol('123') const examId = Symbol('123') console.log(schoolId === examId); // O/P = false bcz we use Symbol datatype with // Basically Symbol datatype providing uniqueness to same value of different variable that's why return type // Symbol datatype is different console.log(typeof schoolId); console.log(typeof examId); // Non-Primivite datatypes // Array,Object,Functions // Array const cricketer = ['Virat','Rohit','Gill'] console.log(typeof cricketer); // O/P -> objects console.log(cricketer); const myObj= { age:"22", name_3:'harsh', } console.log(typeof myObj); console.log(myObj); const myFunction = function(){ console.log("Hello World"); } console.log(typeof myFunction); // O/P -> Function // But technically in JS typeof myFunction = object function console.log(myFunction);
There are two types of data types in jS 1- primitive data type & Return type Objects in js ------ 1) Number --> Number 2) String --> string 3) Boolean --> Boolean 4) Bigint --> Bigint 5) Null --> Object 6) undefine ---> undefine 7) Symbol --> Symbol 2- non primitive data types 1) Arrays --> Arrays 2) Objects --> Objects 3) Functions --> object Function
Hi Hitesh, I noticed a small mistake in the video. You commented out the variable bigNumber, which caused it to show undefined when you checked the datatype. When you check the datatype of an undefined variable, it shows undefined. If you hadn't commented it out, you would have seen Bigint as the datatype for bigNumber. Despite this minor error, I have to say I respect the effort you put into this course. I'm really enjoying it and appreciate the detailed explanations. Thank you for offering such a comprehensive JavaScript course for free!
String = string number = number Boolean = boolean symbol = symbol bigInt = bigInt undefined = undefined null = object array = object function = function object = object
# Things that learnt 1)Javascript is a dynamically typed language because data type will automatically assigned at the time of compilation or code execution. 2.) data types : two types i) primitive data type String, Number, Boolean, null, undefined, Symbol, BigInt ii) Non primitive Array , Objects, Functions
number -> number string -> string bigInt -> bigInt boolean -> boolean undefined -> undefined null -> object symbol -> symbol function->object [object function] all other non-primitive datatypes -> object
type and type of, for return value primitive data types: null - object undefined - undefined number - number string - string bigInt - bigInt boolean - boolean symbol - symbol non-primitive(reference type) : Array - object function - function(object-function, functional object) object - object
JavaScript is a dynamically typed language Return type of variables in JavaScript Primitive Datatypes Number => number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint Non-primitive Datatypes Arrays => object Function => function Object => object
Return type of different datatype in js 1) Primitive Datatype Number=>number String => string Boolean => boolean null => object Undefined=> undefined symbol=> symbol BigInt => bigint 2) Non Primitive Datatype Arrays => object Function => function Object => object
1) primitive data type number => number string => string boolean => boolean null = object BigInt => number symbol => symbol undefined => undefined 2) reference data types array => object object => object function => function
Return of Variables in JS: Primitive Data Types: Number -> Number String -> String Boolean -> Boolean null -> Object undefined -> undefined Symbol -> Symbol Non Primitive / Reference Data Types: Array -> object Object -> object function -> function object (object)
JavaScript is a dynamic language. This means that variables in JavaScript are not explicitly typed, and their types can change during the execution of a program. Additionally, JavaScript allows for features like dynamic typing, where variables can hold values of any type, and dynamic evaluation, where code can be constructed and executed at runtime.
"Hey Chai or Code and Hitesh Choudhary, I'm on the edge of my seat in anticipation for the backend full series and DSA series on this channel! ☕💻 Your content is like the perfect blend of coding wisdom and the soothing essence of chai, and I can't wait to dive deep into these topics with your expert guidance. Keep brewing up those fantastic tutorials, and I'll keep sipping and coding along! 🚀🔥"
return type in the javascript 1) primitive datatypes number ->number string-> string boolean -> boolean null ->object undefined->undefined symbol->symbol
Javascript is dynamic Language and datatypes returned for 1. Primitive Datatypes: String = String Number = number Boolean = boolean Null = object Undefined = undefined Symbol = symbol bigInt = bigInt 2. Non-Primitve Function = function (obj function ) Array = object Object = object.
Return type of variables in JavaScript ======================= Primitive Datatypes --------------------------------------------------- Number => number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint ======================== Non-primitive Datatypes --------------------------------------------- Arrays => object Function => function Object => object
So here are the dataypes with their typeof . Primitive datatype => Number datatype is Number Null datatype is Object Boolean datatype is Boolean Undefined datatype is Undefined Symbol data type is Symbol Bigint datatype is BigInt Non Primitive datatype => Array datatype is Object Object datatype is also Object Function dataype is also function
How datatypes are treated by typeof operator Pmitive Number => number String => string Boolean => boolean null => object // js implementation uses a type tag to indicate the type of value and type tag for objects is 0 and consequently null is used to represent a null pointer therefore the type tag assigned to null was 0, which is same as an object and hence null is treated as an object by typeof operator. undefined => undefined Symbol => symbol BigInt => bigint Non-Primitive Arrays => object Function => function Object => object
JavaScript is a dynamically type language because in this language type of a variable is known at "runtime". So we don't need to specify type of varialbe when we declare it .
Return types of variable in javaScript 1) Primitive DataTypes String = "string" Number = Number Boolean = true/false Null = Null Undefine = undefine Symbol = Symbol BigInt = BigInt 2) Non-Primitive DataTypes Array = object Function = Function
PRIMITIVE DATATYPE Number => number null => object undefined => undefined string => string symbol => symbol boolean => boolean Non-PRIMITIVE DATATYPE array => function object => function function => function object
JavaScript is a dynamically typed language means the type of data initializations is implicitly (automatic - self defined) based on its inbuild standards, Explicitly means we are defining the whole, implicitly means, javascript itself decides which type of data.
Hello ji sir, agar aap variable ( talking about bigNumber example ) ko comment karke typeof function use karoge toh undefined hi aayega! Ji, Namaskar sir ji ..!
for Primitive Data Types number -> number Boolean -> boolean String -> String undefined -> undefined Null -> object Symbol -> symbol BigInt -> bigInt Reference Data Type ( non - primitive ) Arrays -> object object -> object function -> function
/* Primitve Datatypes - [ Always works on call by value i.e. it gives the copy of the address so any changes leads to the change in copy] 1. String 2. Number 3. Boolean 4. Null (empty) 5. undefined 6. symbol -> used to make the compeonent unique so, we use sybmol 7. BigInt (bigger integer) */ /* Non-primitve Datatypes [reference] [ Here we can directly make change in the memory i.e. Call by refernce ] return typeof Non-primitve datatype is always object 1. Arrays 2. Objects 3. Functions */ const arr = ["Car", "bus", "truck"]; console.log(arr); let myObj = { name: "Nav", age: "22", occupation: "Software Engineer", }; console.log(myObj); const myFunc = function () { console.log("Hello World"); }; /* JS is dynamically typed language as it performs the check on runtime during the execution of the code. */ console.log(typeof myFunc);
1) permitive data types number => number string => string boolen => boolen undefined => undefined null => object symbol => symbol bignit => bignit 2) Reference data type Array => object object => object function => function
Return type of in JavaScript 1) Primitive Datatype (Non-Reference Datatype) Number => number String => string Boolean => boolean null => object undefined => undefined Symbol => symbol BigInt => bigint 2) Non-primitive (Reference Datatype) Arrays => object Function => object function Object => object
Return type of variables in JavaScript
1) Primitive Datatypes
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
2) Non-primitive Datatypes
Arrays => object
Function => function
Object => object
Tq
When you learn further prototype, function also acts as a object. Object is the parent one.
@@rupeshjadhav943 as sir said, it is basically object function
@ankita-vz4rb tum bohot mast kaam karta ha maksud bhai
thanks man :)
JavaScript is a dynamically typed language. This means that variable types are determined at runtime, and you do not need to explicitly declare the type of a variable before using it. You can assign different types of values to a variable during its lifetime.
For example, in JavaScript, you can do the following:
let x = 10; // x is now a number
x = "Hello"; // x is now a string
x = true; // x is now a boolean
On the other hand, statically typed languages require you to declare the variable's type explicitly, and the type checking is done at compile-time, before the code is executed.
Languages like Java, C++, and TypeScript are statically typed, and they require you to specify the variable type explicitly when declaring them:
int x = 10; // x is a variable of type int
String name = "John"; // name is a variable of type String
JavaScript's dynamic typing allows for more flexibility but can lead to potential runtime errors if not handled carefully. Static typing, on the other hand, provides better type safety at the cost of some initial verbosity and strictness.
nice gpt bhai
Python also
JavaScript is a dynamically typed language. Because data type will automatically assigned at the time of compilation or code execution.
yess just in time compilation language
Primitive DataTypes:
1.Number: Represents both integer and floating-point numbers. Example: 5, 3.14.
2.String: Represents a sequence of characters enclosed in single or double quotes. Example: "Hello, world!".
3,Boolean: Represents a binary value, either true or false, often used for conditional logic.
4.Undefined: Represents a variable that has been declared but hasn't been assigned a value yet. Example: let x;.
5.Null: standalone value it is represenataion of empty value it is special type and it is a object type. Example: let y = null;
6.Symbol (ES6): it is mostly used used to find uniqnece.
7.BigInt (ES11): Represents large integers that cannot be represented by the Number type.
Refence (Object Data Types):
1.Object: Represents a collection of key-value pairs (properties and methods). Example: { name: "John", age: 30 }.
2.Array: Represents a list-like collection of values, indexed by numbers (integer indices). Example: [1, 2, 3, 4].
3.Function: Represents a reusable block of code that can be invoked or called with arguments. Example: function add(x, y) { return x + y; }.
4.Date: Represents dates and times.
5.RegExp: Represents regular expressions for pattern matching.
lets talk about some Range of Primitive DataType:
1.Number:
Represents both integers and floating-point numbers.
Typical Range: -9,007,199,254,740,992 (-2^53) to 9,007,199,254,740,992 (2^53) inclusive.
Smallest Increment: 2^(-52).
2.String:
Represents a sequence of characters.
No specific range limit, but practical limits depend on memory and system resources.
3.Boolean:
Represents true or false.
Only two possible values: true and false.
4.Undefined:
Represents a variable that has been declared but hasn't been assigned a value.
It has only one possible value: undefined.
5.Null:
Represents the intentional absence of any object or value.
It has only one possible value: null.
6.Symbol (ES6):
Represents a unique and immutable value.
No specific range limit.
7.BigInt (ES11):
Represents large integers that cannot be represented by the Number type.
The range is practically unlimited and depends on available memory.
thanks dude
Thanks
Thanks buddy
Thank you sir for your guidance and hard work here is your gift
* Premitive Datatypes
Type typeof
i) Number number
ii) String string
iii) Boolean boolean
iv) Bigint bigint
v) Symbol symbol
vi) Null object
vii) Undefined undefined
* Non-Premitive OR Referance OR Object datatype
Type typeof
i) Object object
ii) Array object
iii) Function function(object)
This is my research and output if anythig is wrong please feel proud to reply me
Thank you sir
Nice 👍
Primitive datatypes:
String - string
Number - number
Boolean - Boolean
Null - object(****)
Undefined - undefined
BigInt - bigint
Non-primitive datatypes:
Array - object
Function - function(object)
Object - object
thanks mate
when you say "sirf padhna thode hai, interviews bhi crack karne hain" that thing makes your JS tutorials different and unique from others. Although I am writing this comment in English but I just...can't tell you how much this Hindi tutorials are helping me as well as thousand others #ThankYouHiteshSir❤❤
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them.
Thank you sir for your Hard work and guidance ❤
Sir at 14:18, bigNumber ka value isliye undefined aaya kyuki aapne uski declaration ko hi comment kr diya tha 😅
When I tried that declaration myself, it shows the type to bigint 👨💻
I'm still confused here that why JS doesn't throw us an error like variable not defined or not initialised
@@anuragsuryawanshi4177 because js is duck typed or loosely typed language
@@peacecode7 because bignumber was not defined
@@deepakshukla1810 it was defined, but when sir was commenting out console.logs , in order to provide a cleaner output, he mistakenly commented the declaration of bigNumber.
Type and typeof return value
number - number
string - String
boolean - boolean
symbol - symbol
bigint - bigint
undefined - undefined
null - object
array - object
object - object
function - function
but function is not only function it is object-function
Sir When you said this "sirf padhna thode hai, interviews bhi crack karne hain" hits different and motivate to learn from you. #thankyouhiteshsir for making such valuable Javascript course playlist
There are two categories of data types:
1)Primitive: These are call-by-value. The types of primitive data types include String, Number, Boolean, Null, Undefined, Symbol, and BigInt. Note that Symbols uniquely identify variables, even if two variables have the same data and data type. Primitive variables datatype is same but null datatype is object
2) Non-primitive: These are call-by-reference. The types of non-primitive data types are Array, Object, and Function. The data type for these is 'object,' but for functions, they return a data type of 'function,' though they also have an object data type.
There are mainly 2 types of datatypes :
1. Primitive ( call by value = copy version ):
- string => string
- number => number
- Boolean => boolean
- null => object
- undefined => undefined
- symbol => symbol
- Bigint => Bigint
2. Non-Primitive ( reference type ):
- Array => object
- Object => object
- Function => Object Function
3. JavaScript is "Dynamically typed language" because all type checks are being performed during Runtime .
Really sir this series is awesome from the courses thanks your explanation like this way admirable things that you are doing.
Such a great learning with a great teacher love you sir from Pakistan Multan ❤️❤️❤️
Primitive Data Types:
Number -> Example: 42
String -> Example: "Hello, World"
Boolean -> Example: true
null -> Example: null
undefined -> Example: undefined
Symbol -> Example: Symbol("unique")
Non-Primitive Data Types:
Array -> Example: var fruits = ['apple', 'banana', 'cherry']
Function -> Example:
function greet(name) {
console.log("Hello, " + name + "!");
}
ab tak ka sabse shandar channel ,apka padhane ka tareeka real me best h bhaiya
Return Typeof Datatypes:
Primitive Datatypes:
string => string
number => number
Boolean => boolean
Null => object
undefined => undefined
symbol => symbol
bigInt => bigint
Non - Primitives :
Array => object
Object => object
Function => function
function ka datatype = function object h
Primitive Datatypes ka return type
String => String
Number => Number
Boolean => Boolean
Null => Object
Undefined => Undefined
Symbol => Symbol
BigInt => BigInt
Reference Datatypes ka return type
Array => Object
Object => Object
Function => Function
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them.
Return types of variables in js:
Primitive datatypes:
Number =>number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
Reference (Non primitive data types):
Array => object
Object => object
Function => function
02:16 JavaScript data types can be categorized into primitive and non-primitive types.
04:32 Primitive data types in JavaScript
06:48 JavaScript data types
09:04 JavaScript data types include numbers, booleans, null, and undefined
11:20 Symbol and BigInt data types
13:36 Arrays and objects are non-primitive types in JavaScript
15:52 Using typeof function to find data types of variables
18:02 The return type for all non-primitive types is object function.
--> Primitive Datatypes (call by value)
1. Number -> number
2. String -> string
3. Undefined -> undefined
4. Null -> object
5. BigInt -> bigint
6. Boolean -> boolean
7. Symbol -> symbol
--> Non Primitive Datatypes (call by reference)
1. Object -> object
2. Array -> object
3. Function -> function
"Chai aur Code, you've made JavaScript feel like a breeze. Your passion for teaching shines through!"
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them.
02:16 JavaScript data types can be categorized into primitive and non-primitive types.
04:32 Primitive data types in JavaScript
06:48 JavaScript data types
09:04 JavaScript data types include numbers, booleans, null, and undefined
11:20 Symbol and BigInt data types
13:36 Arrays and objects are non-primitive types in JavaScript
15:52 Using typeof function to find data types of variables
18:02 The return type for all non-primitive types is object function.
Crafted by Merlin AI.
JavaScript is a dynamic language. Because wo do not need to declare its data type.
There are two type of Data type
1) Permitve 2) Non Permitve
Permitve Data Type
Number = Number ;
String = String :
Boolean = True / False ;
symbol => Use to Identify the Components or Variable ;
Null => Have NO value ;
Undefind => Mean you do not assign a value ;
bigInt => Use for big Number ;
2) Non Permitive
Array => Array contain a collection of data on different index ;
Object => object is a New version of Array. And it contain the data in collect with respect to its Key Point ;
Function => Its return type is objectFunction
At 13:57, You commented the variable declaration, that's why the typeof of BigInt value is showing 'undefined' because it couldn't find the variable. The actual typeof value of any BigInt variable is bigint and not undefined.
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them...
it is an dynamically typed language because the value of the variables is checked at the run time and may change further according to needs
for typeof operator:for non primitive datatypes:
arr, object:object
and for function :object function
for primitive datatype:
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
Javascript is dynamically typed language which means agar program me aage jakar variables ki value ka datatype change hota hai toh Javascript variables ke value ke current datatype ko hi valid manegi.
Jo mujhe samaj aaya vo kuch aisa tha.
JavaScript ek "dynamically typed" language hai, yani ki isme variable ki data type runtime (execution time) par decide hoti hai, aur aap ek variable mein alag-alag data types ke values store kar sakte hain. JavaScript mein aap ek variable ko pehle number, phir string, aur phir boolean ke roop mein istemal kar sakte hain, aur interpreter runtime par type checks karta hai.
// primitive datatypes
// 1. string
// 2. number
// 3. boolean
// 4. null
// 5. undefined
// 6. symbol
// 7. bigint
// non-primitive / Refference datatypes
// 1. arrays
// 2. objects
// 3. functions
1)primtive type datatypes:-
Number=>number
null=>object
boolean=>boolean
BigInt=>bigInt
string=>string
undefined=>undefind
Symbol=>symbol
2) Non - primitive Datatypes
Array => object
function => functon obj
object => object
*********RESULT OF typeof OPERATOR**********
1.PRIMITIVE
Number :- number
String :- string
Boolean :- boolean
Bigint :- bigint
Undefined :- undefined
Null :- object
Symbol :- symbol
2.RFERENCE TYPE ( NON PRIMITIVE )
Array :- object
Function :- function
Object :- object
JavaScript is a dynamically typed language, which means that variables in JavaScript can hold values of any type, and the type of a variable can change at runtime. This flexibility allows for more fluid and adaptable programming, where you don't have to declare the type of a variable explicitly before using it.
dynamically typed language
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them
Once again your way of teaching extra ordinary sir .
Data Types :
Number > number
String > string
Boolean > boolean
BigInt > bigInt
Symbol > symbol
null > object
☺☺☺☺☺☺☺
Non Primitive Data type (function, object, Array) > object
Return types of variables in JS
1) Primitive Datatypes:
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
2) Non-primitive Datatypes
Arrays => object
Function => function
Object => object
Javascript is a dynamic typing language. When you declare a variable, you do not need to specify what type this variable is
JavaScript is a dynamic programming language.
Dynamic Typing: Variables in JavaScript are not bound to a specific data type. You can assign a value of any type to a variable, and you can reassign a different type to the same variable without any issues.
Dynamically Typed because the datatype needs not to be mentioned while initializing, also the datatype of variable is determined during the runtime
finally wait is end. Very helpful lecture, Hope content will continue. ☑☑☑☑
JavaScript is a dynamically typed language.
In a dynamically typed language like JavaScript, variable types are determined at runtime, not at compile time. This means that you don't have to explicitly declare the data type of a variable when you create it, and you can change the type of a variable by assigning a value of a different type to it during the execution of the program.
Thank you for making such a beautiful javascript tutorial. Because You teach the actual javascript which is necessary for actual production development need. Very Very thank you. I will share your channel as much as possible to everyone. I really like your teaching style and I aslo need that type of javascript teacher. God bless you.
return type of variable in javascript
---primitive datatypes---
number =>number;
string => string;
null => object;
boolean => boolean;
bigInt => null;
undefined => undefined;
symbol => symbol;
---non primitive---
array => object;
function => function;
object =>object;
// Return types of variables in JavaScript
1) Primitive Datatypes
- Number: number
- String: string
- Boolean: boolean
- null: object
- undefined: undefined
- Symbol: symbol
- BigInt: bigint
2) Non-primitive Datatypes
- Arrays: object
- Function: function
- Object: object
JavaScript is a dynamically typed language, which means that data types of variables are determined by the value they hold at runtime and can change throughout the program as we assign different values to them.
Thank you so much sir for these amazing tutorials 🥰🙌
Return type of variables in Js
1) Primitive Datatype
String => string
Number => number
Boolean => boolean
Null => object
Undefined => undefined
Symbol => symbol
BigInt => bigint
2) Non-primitive Datatype
Array => object
Object => object
Function => function
JavaScript is a dynamically typed language.
Datatype in javascript :-
1 . Primitive :- String, Number,BigInt,Boolean,Null, undefined, Symbol
2.Non-premitive :- Array, Object,Function
Return type of Datatype :-
Console.log(typeof("Vishnu")) = String
Number = number
Boolean = Boolean
Null = Object
Undefined = undefined
BigInt = undefined
Array object = Object
Function = object Function
JavaScript is a Dynamically Typed Language. Because data types of the variable are determined by the value they hold at a runtime and it can be changed throughout the program.
Primitive data types : String, Number, Boolean, null, undefined, Symbol, BigInt
Reference type : Array, Object, Function
String - string
Number - number
Boolean - boolean
Null - object
Undefined - undefined
BigInt - bigint
Symbol - symbol
Array - object
Function - function
Object - object
JavaScript is a dynamic language and not static, which means that variables can hold values of different types during runtime.
2 types of dataTypes
1: Primitive
*****7 types of Primitive DataTypes ****
1: Number returns number
2: Boolean returns boolean
3: String returns string
4: undefined returns undefined
5: null returns Object
6: bigint returns Bigint
7: Symbol returns symbol
2: Reference (Non-Primitive)
1: Arrays returns object
2: Function returns function
3: Object returns object
There are 2 data types in Js
1. Primitives
2. Reference (Non Primitives)
Primitives:
1. Number
Example: let number = 100
2. String
Example: let string = "Namaskar"
3. Boolean
Example: let isPurchased = false
4. Undefined
Example: let subscribe;
5. Null
Example: let like = null
6. Symbol
Example: const share = ("100")
7. BigInt
Example: const number = 100000000000n
Reference:
1. Arrays
Example: let objectArrays = [1,2,3]
2. Objects
Example: let video = {
subscribed: true,
like: true,
share: false
}
3. Function
Example: function sheryiansStudent() {
canMakeAwesomeWebs: true
}
Categorisation of data types is on the basis of, how the data is stored in memory and how it is accessed.
Primitive is call by value, means if you assign one variable to another then you don't get the reference of data from memory, you get the copy of the value and if you make any changes in second variable it will not change anything in original data.
Reference(Non-primitive) here you get the reference of the data from memory and thus refers to same data, if any changes made to data, it will reflect in all the variables referring to it.
// Video 9:-
// In this code I explained about primitive and non-primitive datatypes
// Primitive datatypes
let age=22
let name_2="Harsh"
let isEligible=true
let temperature=null
let accountId=undefined
console.log(typeof age);
console.log(typeof name_2);
console.log(typeof isEligible);
console.log(typeof temperature);
console.log(typeof accoutId);
// Special primitive data type is Symbol
const schoolId = Symbol('123')
const examId = Symbol('123')
console.log(schoolId === examId); // O/P = false bcz we use Symbol datatype with
// Basically Symbol datatype providing uniqueness to same value of different variable that's why return type
// Symbol datatype is different
console.log(typeof schoolId);
console.log(typeof examId);
// Non-Primivite datatypes
// Array,Object,Functions
// Array
const cricketer = ['Virat','Rohit','Gill']
console.log(typeof cricketer); // O/P -> objects
console.log(cricketer);
const myObj= {
age:"22",
name_3:'harsh',
}
console.log(typeof myObj);
console.log(myObj);
const myFunction = function(){
console.log("Hello World");
}
console.log(typeof myFunction); // O/P -> Function
// But technically in JS typeof myFunction = object function
console.log(myFunction);
There are two types of data types in jS
1- primitive data type &
Return type Objects in js ------
1) Number --> Number
2) String --> string
3) Boolean --> Boolean
4) Bigint --> Bigint
5) Null --> Object
6) undefine ---> undefine
7) Symbol --> Symbol
2- non primitive data types
1) Arrays --> Arrays
2) Objects --> Objects
3) Functions --> object Function
Hi Hitesh,
I noticed a small mistake in the video. You commented out the variable bigNumber, which caused it to show undefined when you checked the datatype. When you check the datatype of an undefined variable, it shows undefined. If you hadn't commented it out, you would have seen Bigint as the datatype for bigNumber.
Despite this minor error, I have to say I respect the effort you put into this course. I'm really enjoying it and appreciate the detailed explanations. Thank you for offering such a comprehensive JavaScript course for free!
1. Primitive Datatypes
Number -> number
String -> String
Boolean -> Boolean
null -> object
Undefined -> Undefined
Symbol -> Symbol
BigInt -> BigInt
2. Non-Primitive Datatypes
Arrays -> Objects
Functions -> Function
Object -> Object
1.primitive type
number=>number
string=>string
boolean=>boolean
symbol=>symbol
null=>object
undefined=>undefined
bigint=>bigint
2.non primitive type
arrays=>object
object=>object
function=>function
Number = Number
String = String
Null = objects
Boolean = Boolean
undifined = undifined
Symbol = Symbol
Arrays = Objects
Function = functions
objects = objects
sir aapne galat statement ko comment out kar diya isiliye bigint ka data type undefined bata raha tha wo koi special case nahi tha.
JavaScript is a dynamically typed language. Because data type will automatically assigned at the time of compilation or code execution. TX sir....
String = string
number = number
Boolean = boolean
symbol = symbol
bigInt = bigInt
undefined = undefined
null = object
array = object
function = function
object = object
# Things that learnt
1)Javascript is a dynamically typed language because data type will automatically assigned at the time of compilation or code execution.
2.) data types : two types
i) primitive data type
String, Number, Boolean, null, undefined, Symbol, BigInt
ii) Non primitive
Array , Objects, Functions
number -> number
string -> string
bigInt -> bigInt
boolean -> boolean
undefined -> undefined
null -> object
symbol -> symbol
function->object [object function]
all other non-primitive datatypes -> object
type and type of, for return value
primitive data types:
null - object
undefined - undefined
number - number
string - string
bigInt - bigInt
boolean - boolean
symbol - symbol
non-primitive(reference type) :
Array - object
function - function(object-function, functional object)
object - object
JavaScript is a dynamically typed language
Return type of variables in JavaScript
Primitive Datatypes
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
Non-primitive Datatypes
Arrays => object
Function => function
Object => object
Return type of different datatype in js
1) Primitive Datatype
Number=>number
String => string
Boolean => boolean
null => object
Undefined=> undefined
symbol=> symbol
BigInt => bigint
2) Non Primitive Datatype
Arrays => object
Function => function
Object => object
Sir, at 14:08 you comment out bigInt, line no.17 thats why the result of typeof bigNumber came undefined.
Primitive Datatypes :
String => String
Number => number
Nul => object
Boolean => boolen
Undefined => undefined
BigInt = > bigInt
Symbol => symbol
Non-primitive
Arrays => array
Functionz => function
Object => object
1) Primitive Datatypes
// string , number , boolean, null, undefined, symbol,
console.log(typeof string)
//String
console.log(typeof number)
//number
console.log(typeof boolean)
//boolean
console.log(typeof null)
//object
console.log(undefined)
//Undefiend
2) Non-primitive Datatypes
//Array , functions, objects
console.log(array)
//object
console.log(typeof function)
//function
console.log(typeof object)
//Object
Primitive Datatypes
String -> string
Number -> Number
undefined - > undefined
Boolean -> boolean
Array -> Object
Functions -> Function Object
Object -> Object
1) primitive data type
number => number
string => string
boolean => boolean
null = object
BigInt => number
symbol => symbol
undefined => undefined
2) reference data types
array => object
object => object
function => function
Return of Variables in JS:
Primitive Data Types:
Number -> Number
String -> String
Boolean -> Boolean
null -> Object
undefined -> undefined
Symbol -> Symbol
Non Primitive / Reference Data Types:
Array -> object
Object -> object
function -> function object (object)
JavaScript is a dynamic language. This means that variables in JavaScript are not explicitly typed, and their types can change during the execution of a program. Additionally, JavaScript allows for features like dynamic typing, where variables can hold values of any type, and dynamic evaluation, where code can be constructed and executed at runtime.
"Hey Chai or Code and Hitesh Choudhary, I'm on the edge of my seat in anticipation for the backend full series and DSA series on this channel! ☕💻 Your content is like the perfect blend of coding wisdom and the soothing essence of chai, and I can't wait to dive deep into these topics with your expert guidance. Keep brewing up those fantastic tutorials, and I'll keep sipping and coding along! 🚀🔥"
return type in the javascript
1) primitive datatypes
number ->number
string-> string
boolean -> boolean
null ->object
undefined->undefined
symbol->symbol
Javascript is dynamic Language and datatypes returned for
1. Primitive Datatypes:
String = String
Number = number
Boolean = boolean
Null = object
Undefined = undefined
Symbol = symbol
bigInt = bigInt
2. Non-Primitve
Function = function (obj function )
Array = object
Object = object.
Return type of variables in JavaScript
=======================
Primitive Datatypes
---------------------------------------------------
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
========================
Non-primitive Datatypes
---------------------------------------------
Arrays => object
Function => function
Object => object
So here are the dataypes with their typeof .
Primitive datatype
=>
Number datatype is Number
Null datatype is Object
Boolean datatype is Boolean
Undefined datatype is Undefined
Symbol data type is Symbol
Bigint datatype is BigInt
Non Primitive datatype
=>
Array datatype is Object
Object datatype is also Object
Function dataype is also function
string => datatype string
null => object
number => number
symbol => symbol
boolean => boolean
bigint=> bigint
undefined => undefined
How datatypes are treated by typeof operator
Pmitive
Number => number
String => string
Boolean => boolean
null => object // js implementation uses a type tag to indicate the type of value and type tag for objects is 0 and consequently null
is used to represent a null pointer therefore the type tag assigned to null was 0, which is same as an object and hence null is treated as an object by typeof operator.
undefined => undefined
Symbol => symbol
BigInt => bigint
Non-Primitive
Arrays => object
Function => function
Object => object
Primitive data type
1) string - return string
2) number - return number
3) boolean - return boolean
4) null - return object
5) undefined - return undefined
6) symbol
7) bigint - return bigint
Best tutorial for JS
JavaScript has dynamically typed language each variable will be set dynamically during code execution.
JavaScript is a dynamically type language because in this language type of a variable is known at "runtime". So we don't need to specify type of varialbe when we declare it .
aaj naya sikha ki primitive call by value hote hai aur non primitive call by reference hote hai
thank you sir
Return types of variable in javaScript
1) Primitive DataTypes
String = "string"
Number = Number
Boolean = true/false
Null = Null
Undefine = undefine
Symbol = Symbol
BigInt = BigInt
2) Non-Primitive DataTypes
Array = object
Function = Function
PRIMITIVE DATATYPE
Number => number
null => object
undefined => undefined
string => string
symbol => symbol
boolean => boolean
Non-PRIMITIVE DATATYPE
array => function
object => function
function => function object
JavaScript is a dynamically typed language means the type of data initializations is implicitly (automatic - self defined) based on its inbuild standards, Explicitly means we are defining the whole, implicitly means, javascript itself decides which type of data.
Hello ji sir, agar aap variable ( talking about bigNumber example ) ko comment karke typeof function use karoge toh undefined hi aayega! Ji, Namaskar sir ji ..!
Primitive datatypes:
Number => number
string => string
boolean => boolean
null => =object
undefined => undefined
symbol => symbol
Bigint => Bigint
Reference:
Arrays => Objects
Function => function
object => object
Return Types
Primitives
Number->Same
String ->Same
BigInt->Same
Boolean->Same
Null->Object
Undefined->Same
Non Primitve
Arrays => object
Function => function
Object => object
for Primitive Data Types
number -> number
Boolean -> boolean
String -> String
undefined -> undefined
Null -> object
Symbol -> symbol
BigInt -> bigInt
Reference Data Type ( non - primitive )
Arrays -> object
object -> object
function -> function
/*
Primitve Datatypes - [ Always works on call by value i.e. it gives the copy of the address so any changes leads to the change in copy]
1. String
2. Number
3. Boolean
4. Null (empty)
5. undefined
6. symbol -> used to make the compeonent unique so, we use sybmol
7. BigInt (bigger integer)
*/
/*
Non-primitve Datatypes [reference] [ Here we can directly make change in the memory i.e. Call by refernce ]
return typeof Non-primitve datatype is always object
1. Arrays
2. Objects
3. Functions
*/
const arr = ["Car", "bus", "truck"];
console.log(arr);
let myObj = {
name: "Nav",
age: "22",
occupation: "Software Engineer",
};
console.log(myObj);
const myFunc = function () {
console.log("Hello World");
};
/*
JS is dynamically typed language as it performs the check on runtime during the execution of the code.
*/
console.log(typeof myFunc);
1) permitive data types
number => number
string => string
boolen => boolen
undefined => undefined
null => object
symbol => symbol
bignit => bignit
2) Reference data type
Array => object
object => object
function => function
Return type of in JavaScript
1) Primitive Datatype (Non-Reference Datatype)
Number => number
String => string
Boolean => boolean
null => object
undefined => undefined
Symbol => symbol
BigInt => bigint
2) Non-primitive (Reference Datatype)
Arrays => object
Function => object function
Object => object
JS -Dynamically Typed, that helps in easy handling of data