Javescript——数据类型
Posted panpanwelcome
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Javescript——数据类型相关的知识,希望对你有一定的参考价值。
原文链接:Understanding Data Types in JavaScript
Data types are used to classify one particular type of data in programming languages. For instance, a number and a string of characters are different types of data that will be treated differently by javascript.
This is important because the specific data type you use will determine what values you can assign to it and what you can do to it. This is to say, to be able to do operations with variables in JavaScript, it is important to understand the data type of any given variable.
Dynamic Typing
JavaScript has dynamic data types, meaning that type checking is done at runtime rather than compile time. Python’s data types are also dynamically typed.
With dynamically typed languages, a variable of the same name can be used to hold different data types.
For example, the variable t
, defined as a variable by the let
keyword (note that let
keeps a given variable limited in scope), can be assigned to hold different data types, or can be initialized but left undefined:
let t = 16; // t is a number let t = "Teresa"; // t is a string let t = true; // t is a Boolean let t; // t is undefined
Each of the variables t
above can be set to any data type available in JavaScript; they do not need to be explicitly declared with a data type before they are used.
Numbers
JavaScript has only one number type, there is no separate designation for integers and floating-point numbers. Because of this, numbers can be written in JavaScript with or without decimals:
let num1 = 93; let num2 = 93.00;
In both cases above, the data type is a number and is the same regardless of whether or not the number has decimal points.
Scientific exponential notation can be used in JavaScript to abbreviate very large or small numbers, as in the following examples:
let num3 = 987e8; // 98700000000 let num4 = 987e-8; // 0.00000987
Numbers in JavaScript are considered to be accurate up to 15 digits. That means that numbers will be rounded after the 16th digit is reached:
let num5 = 999999999999999; // remains as 999999999999999 let num6 = 9999999999999999; // rounded up to 10000000000000000
Infinity
or -Infinity
will be returned if you calculate a number outside of the largest possible number available in JavaScript. These will also occur for values that are undefined, as when dividing by zero:
let num7 = 5 / 0; // will return Infinity let num8 = -5 / 0; // will return -Infinity
In technical terms, Infinity
will be displayed when a number exceeds the number 1.797693134862315E+308
, which represents the upper limit in JavaScript.
Similarly, -Infinity
will be displayed when a number goes beyond the lower limit of -1.797693134862316E+308
.
The number Infinity
can also be used in loops:
while (num9 != Infinity) { // Code here will execute through num9 = Infinity }
For numbers that are not legal numbers, NaN
will be displayed. If you attempt to perform a mathematical operation on a number and a non-numeric value, NaN
will be returned. This is the case in the following example:
let x = 20 / "Shark"; // x will be NaN
Since the number 20
cannot be divided by the string "Shark"
because it cannot be evaluated as a number, the returned value for the x
variable is NaN
.
However, if a string can be evaluated as a numeric value, the mathematical expression can be performed in JavaScript:
let y = 20 / "5"; // y will be 4
In the above example, since the string "5"
can be evaluated as a numeric value in JavaScript, it is treated as such and will work with the mathematical operator for division, /
.
When assigning the value NaN
to a variable used in an operation, it will result in the value of NaN
, even when the other operand is a legal number:
let a = NaN; let b = 37; let c = a + b; // c will be NaN
There is only one number data type in JavaScript. When working with numbers, any number you enter will be interpreted as the data type for numbers; you are not required to declare what kind of data type you are entering because JavaScript is dynamically typed.
Strings
A string is a sequence of one or more characters (letters, numbers, symbols). Strings are useful in that they represent textual data.
In JavaScript, strings exist within either single quotes ‘
or double quotes "
, so to create a string, enclose a sequence of characters in quotes:
let singleQuotes = ‘This is a string in single quotes.‘; let doubleQuotes = "This is a string in double quotes.";
You can choose to use either single quotes or double quotes, but whichever you decide on you should remain consistent within a program.
There are many operations that we can perform on strings within our programs in order to manipulate them to achieve the results we are seeking. Strings are important for communicating information to the user, and for the user to communicate information back to the program.
Booleans
The Boolean data type can be one of two values, either true or false. Booleans are used to represent the truth values that are associated with the logic branch of mathematics, which informs algorithms in computer science.
Whenever you see the data type Boolean, it will start with a capitalized B because it is named for the mathematician George Boole.
Many operations in math give us answers that evaluate to either true or false:
- greater than
- 500 > 100
true
- 1 > 5
false
- 500 > 100
- less than
- 200 < 400
true
- 4 < 2
false
- 200 < 400
- equal
- 5 = 5
true
- 500 = 400
false
- 5 = 5
Arrays
An array can hold multiple values within a single variable. This means that you can contain a list of values within an array and iterate through them.
Each item or value that is inside of an array is called an element. You can refer to the elements of an array by using an index number.
Just as strings are defined as characters between quotes, arrays are defined by having values between square brackets [ ]
. 】
An array of strings, for example, looks like this:
let fish = ["shark", "cuttlefish", "clownfish", "eel"];
Arrays are a very flexible data type because they are mutable in that they can have element values added, removed, and changed.
Objects
The JavaScript object data type can contain many values as name:value pairs. These pairs provide a useful way to store and access data. The object literal syntax is made up of name:value pairs separated by colons with curly braces on either side { }
.
Typically used to hold data that are related, such as the information contained in an ID, a JavaScript object literal looks like this, with whitespaces between properties:
let sammy = {firstName:"Sammy", lastName:"Shark", color:"blue", location:"ocean"};
Alternatively, and especially for object literals with a high number of name:value pairs, we can write this data type on multiple lines, with a whitespace after each colon:
let sammy = { firstName: "Sammy", lastName: "Shark", color: "blue", location: "Ocean" };
The object variable sammy
in each of the examples above has 4 properties: firstName
, lastName
, color
, and location
. These are each passed values separated by colons.
Working with Multiple Data Types
While each program you create will contain multiple data types, it is important to keep in mind that you will generally be performing operations within the same data type.
That is, you’ll be performing mathematics on numbers, or slicing strings.
When you use an operator that works across data types, like the +
operator that can add numbers or concatenate strings, you may achieve unexpected results.
For example, when using the +
operator with numbers and strings together, the numbers will be treated as a string (thus they will be concatenated), but the order of the data types will influence the concatenation.
So, if you create a variable that performs the following concatenation, JavaScript will interpret each element below as a string:
let o = "Ocean" + 5 + 3; # Output Ocean53
However, if you lead with numbers, the two numbers will be added before they are then interpreted as a string when the program runtime reaches "Ocean"
, so the returned value will be the sum of the two numbers concatenated with the string:
let p = 5 + 3 + "Ocean"; # Output 8Ocean
Because of these unexpected outcomes, you’ll likely be performing operations and methods within one data type rather than across them.
JavaScript, however, does not return errors when mixing data types, as some other programming languages do.
以上是关于Javescript——数据类型的主要内容,如果未能解决你的问题,请参考以下文章