第2天：数据类型

数据类型

在上一节中，我们简单提到了数据类型。数据或值有数据类型。数据类型描述了数据的特征。数据类型可以分为两种：

原始数据类型
非原始数据类型（对象引用）

原始数据类型

JavaScript 中的原始数据类型包括：

Numbers - 整数、浮点数
Strings - 单引号、双引号或反引号下的任何数据
Booleans - true 或 false 值
Null - 空值或无值
Undefined - 声明的变量但没有赋值
Symbol - 可以由 Symbol 构造函数生成的唯一标识符

JavaScript 中的非原始数据类型包括：

Objects - 对象、数组、函数等

现在，让我们看看原始和非原始数据类型的含义。原始数据类型是不可变的（不可修改的）数据类型。一旦创建了原始数据类型，我们就无法修改它。

示例：

let word = 'JavaScript'

如果我们尝试修改存储在变量 word 中的字符串，JavaScript 应该会引发错误。单引号、双引号或反引号下的任何数据都是字符串数据类型。

word[0] = 'Y'

这个表达式不会改变存储在变量 word 中的字符串。所以，我们可以说字符串是不可修改的或者换句话说是不可变的。原始数据类型按值进行比较。让我们比较不同的数据值。请看下面的示例：

let numOne = 3
let numTwo = 3

console.log(numOne == numTwo)      // true

let js = 'JavaScript'
let py = 'Python'

console.log(js == py)             //false 

let lightOn = true
let lightOff = false

console.log(lightOn == lightOff) // false

非原始数据类型

非原始数据类型是可修改或可变的。我们可以在创建后修改非原始数据类型的值。让我们通过创建一个数组来看看。数组是方括号内的值列表。数组可以包含相同或不同的数据类型。数组值通过它们的索引引用。在 JavaScript 中，数组索引从零开始。也就是说，数组的第一个元素在索引零处找到，第二个元素在索引一处找到，第三个元素在索引二处找到，等等。

let nums = [1, 2, 3]
nums[0] = 10

console.log(nums)  // [10, 2, 3]

如您所见，存储在数组中的非原始数据类型是可变的。非原始数据类型无法按值进行比较。即使两个非原始数据类型具有相同的属性和值，它们也不严格相等。

let nums = [1, 2, 3]
let numbers = [1, 2, 3]

console.log(nums == numbers)  // false

let userOne = {
name:'Asabeneh',
role:'teaching',
country:'Finland'
}

let userTwo = {
name:'Asabeneh',
role:'teaching',
country:'Finland'
}

console.log(userOne == userTwo) // false

经验法则，我们不比较非原始数据类型。不要比较数组、函数或对象。非原始值被称为引用类型，因为它们通过引用而不是值进行比较。两个对象只有在引用同一个底层对象时才严格相等。

let nums = [1, 2, 3]
let numbers = nums

console.log(nums == numbers)  // true

let userOne = {
name:'Asabeneh',
role:'teaching',
country:'Finland'
}

let userTwo = userOne

console.log(userOne == userTwo)  // true

如果您很难理解原始数据类型和非原始数据类型之间的差异，那么您并不孤单。保持冷静并继续下一节，稍后再回来。现在让我们开始按数据类型的数字类型。

数字

数字是可以进行所有算术运算的整数和十进制值。让我们看看数字的一些示例。

声明数字类型

let age = 35
const gravity = 9.81  // 我们使用 const 表示不变的值，重力常数（m/s2）
let mass = 72         // 以千克为单位的质量
const PI = 3.14       // pi 几何常数

// 更多示例
const boilingPoint = 100 // 摄氏度的温度，水的沸点是一个常数
const bodyTemp = 37      // 摄氏度的人体平均温度，这是一个常数

console.log(age, gravity, mass, PI, boilingPoint, bodyTemp)

Math 对象

在 JavaScript 中，Math 对象提供了许多处理数字的方法。

const PI = Math.PI

console.log(PI)                            // 3.141592653589793

// 四舍五入到最接近的数字
// 如果高于 .5 向上舍入，如果低于 0.5 向下舍入

console.log(Math.round(PI))                // 3 四舍五入值
console.log(Math.round(9.81))              // 10
console.log(Math.floor(PI))                // 3 向下舍入
console.log(Math.ceil(PI))                 // 4 向上舍入
console.log(Math.min(-5, -10, -2, 0, 5))  // -10，返回最小值
console.log(Math.max(-5, -10, -2, 0, 5))  // 5，返回最大值

const randNum = Math.random() // 创建 0 到 0.999999 之间的随机数
console.log(randNum)

// 让我们创建 0 到 10 之间的随机数
const num = Math.floor(Math.random () * 11) // 创建 0 到 10 之间的随机数
console.log(num)

//绝对值
console.log(Math.abs(-10))      // 10

//平方根
console.log(Math.sqrt(100))     // 10

//幂
console.log(Math.pow(3, 2))     // 9

console.log(Math.E)             // 2.718

// 对数
console.log(Math.log(2))        // 0.6931471805599453
console.log(Math.log(10))       // 2.302585092994046

// 返回以 2 为底的对数和以 10 为底的对数
console.log(Math.log2(2))       // 1
console.log(Math.log10(10))     // 1

// 三角函数
console.log(Math.sin(0))
console.log(Math.sin(60))

console.log(Math.cos(0))
console.log(Math.cos(60))

随机数生成器

JavaScript Math 对象有一个 random() 方法数字生成器，它生成 0 到 0.999999999... 之间的数字

let randomNum = Math.random() // 生成 0 到 0.999 之间的数字

现在，让我们看看如何使用 random() 方法生成 0 到 10 之间的随机数：

let randomNum = Math.random()         // 生成 0 到 0.999 之间的数字
let numBtnZeroAndTen = randomNum * 11

console.log(numBtnZeroAndTen)         // 这给出：最小 0 和最大 10.99

let randomNumRoundToFloor = Math.floor(numBtnZeroAndTen)
console.log(randomNumRoundToFloor)    // 这给出 0 到 10 之间的数字

字符串

字符串是单引号、双引号或反引号下的文本。要声明字符串，我们需要变量名、赋值运算符、单引号、双引号或反引号下的值。让我们看看字符串的一些示例：

let space = ' '           // 空字符串
let firstName = 'Asabeneh'
let lastName = 'Yetayeh'
let country = 'Finland'
let city = 'Helsinki'
let language = 'JavaScript'
let job = 'teacher'
let quote = "The saying,'Seeing is Believing' is not correct in 2020."
let quotWithBackTick = `The saying,'Seeing is Believing' is not correct in 2020.`

字符串连接

连接两个或多个字符串以创建一个字符串。

// 声明不同的变量
let space = ' '
let firstName = 'Asabeneh'
let lastName = 'Yetayeh'
let country = 'Finland'
let city = 'Helsinki'
let language = 'JavaScript'
let job = 'teacher'
let age = 250

let fullName = firstName + space + lastName // 连接，将两个字符串合并为一个
let personInfoOne = fullName + '. I am ' + age + '. I live in ' + country // ES5 字符串加法

console.log(personInfoOne)

Asabeneh Yetayeh. I am 250. I live in Finland

使用加法运算符连接是一种旧方法。这种连接方式繁琐且容易出错。了解如何以这种方式连接是很好的，但我强烈建议使用 ES6 模板字符串（稍后解释）。

长字符串字面量

字符串可以是单个字符、段落或页面。如果字符串长度太大，它不适合一行。我们可以在每行末尾使用反斜杠字符 (\) 来表示字符串将在下一行继续。

示例：

const paragraph = "My name is Asabeneh Yetayeh. I live in Finland, Helsinki.\
I am a teacher and I love teaching. I teach HTML, CSS, JavaScript, React, Redux, \
Node.js, Python, Data Analysis and D3.js for anyone who is interested to learn. \
In the end of 2019, I was thinking to expand my teaching and to reach \
to global audience and I started a Python challenge from November 20 - December 19.\
It was one of the most rewarding and inspiring experience.\
Now, we are in 2020. I am enjoying preparing the 30DaysOfJavaScript challenge and \
I hope you are enjoying too."

console.log(paragraph)

转义序列

在 JavaScript 和其他编程语言中，\ 后跟一些字符是转义序列。让我们看看最常见的转义字符：

\n: 换行
\t: 制表符，表示 8 个空格
\\: 反斜杠
\': 单引号 (')
\": 双引号 (")

console.log('I hope everyone is enjoying the 30 Days Of JavaScript challenge.\nDo you ?') // 换行
console.log('Days\tTopics\tExercises')
console.log('Day 1\t3\t5')
console.log('Day 2\t3\t5')
console.log('Day 3\t3\t5')
console.log('Day 4\t3\t5')
console.log('This is a backslash  symbol (\\)') // 写反斜杠
console.log('In every programming language it starts with \"Hello, World!\"')
console.log("In every programming language it starts with \'Hello, World!\'")
console.log('The saying \'Seeing is Believing\' isn\'t correct in 2020')

控制台输出：

I hope everyone is enjoying the 30 Days Of JavaScript challenge.
Do you ?
Days  Topics  Exercises
Day 1 3 5
Day 2 3 5
Day 3 3 5
Day 4 3 5
This is a backslash  symbol (\)
In every programming language it starts with "Hello, World!"
In every programming language it starts with 'Hello, World!'
The saying 'Seeing is Believing' isn't correct in 2020

模板字符串

要创建模板字符串，我们使用两个反引号。我们可以将数据作为表达式注入模板字符串内。要注入数据，我们将表达式用花括号 ({}) 括起来，前面加上 $ 符号。请参阅下面的语法。

//语法
`String literal text`
`String literal text ${expression}`

示例 1

console.log(`The sum of 2 and 3 is 5`)              // 静态写入数据
let a = 2
let b = 3
console.log(`The sum of ${a} and ${b} is ${a + b}`) // 动态注入数据

示例 2

let firstName = 'Asabeneh'
let lastName = 'Yetayeh'
let country = 'Finland'
let city = 'Helsinki'
let language = 'JavaScript'
let job = 'teacher'
let age = 250
let fullName = firstName + ' ' + lastName

let personInfoTwo = `I am ${fullName}. I am ${age}. I live in ${country}.` //ES6 - 字符串插值方法
let personInfoThree = `I am ${fullName}. I live in ${city}, ${country}. I am a ${job}. I teach ${language}.`
console.log(personInfoTwo)
console.log(personInfoThree)

I am Asabeneh Yetayeh. I am 250. I live in Finland.
I am Asabeneh Yetayeh. I live in Helsinki, Finland. I am a teacher. I teach JavaScript.

使用字符串模板或字符串插值方法，我们可以添加表达式，这些表达式可以是值或一些操作（比较、算术运算、三元运算）。

let a = 2
let b = 3
console.log(`${a} is greater than ${b}: ${a > b}`)

2 is greater than 3: false

字符串方法

JavaScript 中的一切都是对象。字符串是原始数据类型，这意味着一旦创建就无法修改它。字符串对象有许多字符串方法。有不同的字符串方法可以帮助我们处理字符串。

length: 字符串 length 方法返回字符串中的字符数，包括空格。

示例：

let js = 'JavaScript'
console.log(js.length)         // 10
let firstName = 'Asabeneh'
console.log(firstName.length)  // 8

访问字符串中的字符: 我们可以使用索引访问字符串中的每个字符。在编程中，计数从 0 开始。字符串的第一个索引是零，最后一个索引是字符串的长度减一。

let string = 'JavaScript'
let firstLetter = string[0]

console.log(firstLetter)           // J

let secondLetter = string[1]       // a
let thirdLetter = string[2]
let lastLetter = string[9]

console.log(lastLetter)            // t

let lastIndex = string.length - 1

console.log(lastIndex)  // 9
console.log(string[lastIndex])    // t

toUpperCase(): 此方法将字符串更改为大写字母。

let string = 'JavaScript'

console.log(string.toUpperCase())     // JAVASCRIPT

let firstName = 'Asabeneh'

console.log(firstName.toUpperCase())  // ASABENEH

let country = 'Finland'

console.log(country.toUpperCase())    // FINLAND

toLowerCase(): 此方法将字符串更改为小写字母。

let string = 'JavasCript'

console.log(string.toLowerCase())     // javascript

let firstName = 'Asabeneh'

console.log(firstName.toLowerCase())  // asabeneh

let country = 'Finland'

console.log(country.toLowerCase())   // finland

substr(): 它需要两个参数，起始索引和要切片的字符数。

let string = 'JavaScript'
console.log(string.substr(4,6))    // Script

let country = 'Finland'
console.log(country.substr(3, 4))   // land

substring(): 它需要两个参数，起始索引和停止索引，但它不包括停止索引处的字符。

let string = 'JavaScript'

console.log(string.substring(0,4))     // Java
console.log(string.substring(4,10))    // Script
console.log(string.substring(4))       // Script

let country = 'Finland'

console.log(country.substring(0, 3))   // Fin
console.log(country.substring(3, 7))   // land
console.log(country.substring(3))      // land

split(): split 方法在指定位置拆分字符串。

let string = '30 Days Of JavaScript'

console.log(string.split())     // 更改为数组 -> ["30 Days Of JavaScript"]
console.log(string.split(' '))  // 在空格处拆分为数组 -> ["30", "Days", "Of", "JavaScript"]

let firstName = 'Asabeneh'

console.log(firstName.split())    // 更改为数组 - > ["Asabeneh"]
console.log(firstName.split(''))  // 在每个字母处拆分为数组 ->  ["A", "s", "a", "b", "e", "n", "e", "h"]

let countries = 'Finland, Sweden, Norway, Denmark, and Iceland'

console.log(countries.split(','))  // 在逗号处拆分为数组 -> ["Finland", " Sweden", " Norway", " Denmark", " and Iceland"]
console.log(countries.split(', ')) //  ["Finland", "Sweden", "Norway", "Denmark", "and Iceland"]

trim(): 删除字符串开头或结尾的尾随空格。

let string = '   30 Days Of JavaScript   '

console.log(string)
console.log(string.trim(' '))

let firstName = ' Asabeneh '

console.log(firstName)
console.log(firstName.trim())  // 仍然删除字符串开头和结尾的空格

   30 Days Of JavasCript   
30 Days Of JavasCript
  Asabeneh 
Asabeneh

includes(): 它接受一个子字符串参数，并检查子字符串参数是否存在于字符串中。includes() 返回一个布尔值。如果字符串中存在子字符串，则返回 true，否则返回 false。

let string = '30 Days Of JavaScript'

console.log(string.includes('Days'))     // true
console.log(string.includes('days'))     // false - 它区分大小写！
console.log(string.includes('Script'))   // true
console.log(string.includes('script'))   // false
console.log(string.includes('java'))     // false
console.log(string.includes('Java'))     // true

let country = 'Finland'

console.log(country.includes('fin'))     // false
console.log(country.includes('Fin'))     // true
console.log(country.includes('land'))    // true
console.log(country.includes('Land'))    // false

replace(): 将旧子字符串作为参数和新子字符串。

string.replace(oldsubstring, newsubstring)

let string = '30 Days Of JavaScript'
console.log(string.replace('JavaScript', 'Python')) // 30 Days Of Python

let country = 'Finland'
console.log(country.replace('Fin', 'Noman'))       // Nomanland

charAt(): 接受索引并返回该索引处的值

string.charAt(index)

let string = '30 Days Of JavaScript'
console.log(string.charAt(0))        // 3

let lastIndex = string.length - 1
console.log(string.charAt(lastIndex)) // t

charCodeAt(): 接受索引并返回该索引处值的字符代码（ASCII 数字）

string.charCodeAt(index)

let string = '30 Days Of JavaScript'
console.log(string.charCodeAt(3))        // D ASCII 数字是 68

let lastIndex = string.length - 1
console.log(string.charCodeAt(lastIndex)) // t ASCII 是 116

indexOf(): 接受一个子字符串，如果子字符串存在于字符串中，它返回子字符串的第一个位置，如果不存在，它返回 -1

string.indexOf(substring)

let string = '30 Days Of JavaScript'

console.log(string.indexOf('D'))          // 3
console.log(string.indexOf('Days'))       // 3
console.log(string.indexOf('days'))       // -1
console.log(string.indexOf('a'))          // 4
console.log(string.indexOf('JavaScript')) // 11
console.log(string.indexOf('Script'))     //15
console.log(string.indexOf('script'))     // -1

lastIndexOf(): 接受一个子字符串，如果子字符串存在于字符串中，它返回子字符串的最后位置，如果不存在，它返回 -1

//语法
string.lastIndexOf(substring)

let string = 'I love JavaScript. If you do not love JavaScript what else can you love.'

console.log(string.lastIndexOf('love'))       // 67
console.log(string.lastIndexOf('you'))        // 63
console.log(string.lastIndexOf('JavaScript')) // 38

concat(): 它接受许多子字符串并将它们连接起来。

string.concat(substring, substring, substring)

let string = '30'
console.log(string.concat("Days", "Of", "JavaScript")) // 30DaysOfJavaScript

let country = 'Fin'
console.log(country.concat("land")) // Finland

startsWith: 它接受一个子字符串作为参数，并检查字符串是否以指定的子字符串开头。它返回一个布尔值（true 或 false）。

//语法
string.startsWith(substring)

let string = 'Love is the best to in this world'

console.log(string.startsWith('Love'))   // true
console.log(string.startsWith('love'))   // false
console.log(string.startsWith('world'))  // false

let country = 'Finland'

console.log(country.startsWith('Fin'))   // true
console.log(country.startsWith('fin'))   // false
console.log(country.startsWith('land'))  //  false

endsWith: 它接受一个子字符串作为参数，并检查字符串是否以指定的子字符串结尾。它返回一个布尔值（true 或 false）。

string.endsWith(substring)

let string = 'Love is the most powerful feeling in the world'

console.log(string.endsWith('world'))         // true
console.log(string.endsWith('love'))          // false
console.log(string.endsWith('in the world')) // true

let country = 'Finland'

console.log(country.endsWith('land'))         // true
console.log(country.endsWith('fin'))          // false
console.log(country.endsWith('Fin'))          //  false

search: 它接受一个子字符串作为参数，并返回第一个匹配的索引。搜索值可以是字符串或正则表达式模式。

string.search(substring)

let string = 'I love JavaScript. If you do not love JavaScript what else can you love.'
console.log(string.search('love'))          // 2
console.log(string.search(/javascript/gi))  // 7

match: 它接受一个子字符串或正则表达式模式作为参数，如果有匹配则返回一个数组，如果没有则返回 null。让我们看看正则表达式模式是什么样的。它以 / 符号开始并以 / 符号结束。

let string = 'love'
let patternOne = /love/     // 没有任何标志
let patternTwo = /love/gi   // g-表示在整个文本中搜索，i - 不区分大小写

匹配语法

// 语法
string.match(substring)

let string = 'I love JavaScript. If you do not love JavaScript what else can you love.'
console.log(string.match('love'))

["love", index: 2, input: "I love JavaScript. If you do not love JavaScript what else can you love.", groups: undefined]

let pattern = /love/gi
console.log(string.match(pattern))   // ["love", "love", "love"]

让我们使用正则表达式从文本中提取数字。这不是正则表达式部分，不要恐慌！我们稍后会介绍正则表达式。

let txt = 'In 2019, I ran 30 Days of Python. Now, in 2020 I am super exited to start this challenge'
let regEx = /\d+/

// 带转义字符的 d 表示 d 不是普通的 d，而是作为数字
// + 表示一个或多个数字，
// 如果后面有 g，则表示全局，到处搜索。

console.log(txt.match(regEx))  // ["2", "0", "1", "9", "3", "0", "2", "0", "2", "0"]
console.log(txt.match(/\d+/g)) // ["2019", "30", "2020"]

repeat(): 它接受一个数字作为参数并返回字符串的重复版本。

string.repeat(n)

let string = 'love'
console.log(string.repeat(10)) // lovelovelovelovelovelovelovelovelovelove

检查数据类型和类型转换

检查数据类型

要检查某个变量的数据类型，我们使用 typeof 方法。

示例：

// 不同的 javascript 数据类型
// 让我们声明不同的数据类型

let firstName = 'Asabeneh'      // string
let lastName = 'Yetayeh'        // string
let country = 'Finland'         // string
let city = 'Helsinki'           // string
let age = 250                   // number，这不是我的真实年龄，不要担心
let job                         // undefined，因为没有分配值

console.log(typeof 'Asabeneh')  // string
console.log(typeof firstName)   // string
console.log(typeof 10)          // number
console.log(typeof 3.14)        // number
console.log(typeof true)        // boolean
console.log(typeof false)       // boolean
console.log(typeof NaN)         // number
console.log(typeof job)         // undefined
console.log(typeof undefined)   // undefined
console.log(typeof null)        // object

改变数据类型（类型转换）

类型转换：将一种数据类型转换为另一种数据类型。我们使用 parseInt()、parseFloat()、Number()、+ 符号、str() 当我们进行算术运算时，字符串数字应该首先转换为整数或浮点数，否则会返回错误。

字符串转整数

我们可以将字符串数字转换为数字。引号内的任何数字都是字符串数字。字符串数字的示例：'10'、'5' 等。我们可以使用以下方法将字符串转换为数字：

parseInt()
Number()
加号 (+)

let num = '10'
let numInt = parseInt(num)
console.log(numInt) // 10

let num = '10'
let numInt = Number(num)

console.log(numInt) // 10

let num = '10'
let numInt = +num

console.log(numInt) // 10

字符串转浮点数

我们可以将字符串浮点数转换为浮点数。引号内的任何浮点数都是字符串浮点数。字符串浮点数的示例：'9.81'、'3.14'、'1.44' 等。我们可以使用以下方法将字符串浮点数转换为数字：

parseFloat()
Number()
加号 (+)

let num = '9.81'
let numFloat = parseFloat(num)

console.log(numFloat) // 9.81

let num = '9.81'
let numFloat = Number(num)

console.log(numFloat) // 9.81

let num = '9.81'
let numFloat = +num

console.log(numFloat) // 9.81

浮点数转整数

我们可以将浮点数转换为整数。我们使用以下方法将浮点数转换为整数：

parseInt()

let num = 9.81
let numInt = parseInt(num)

console.log(numInt) // 9

🌕 你太棒了。你刚刚完成了第 2 天的挑战，你在通往伟大的道路上领先了两步。现在为你的大脑和肌肉做一些练习。

💻 第 2 天：练习

练习：级别 1

声明一个名为 challenge 的变量并为其分配初始值 '30 Days Of JavaScript'。
使用 console.log() 在浏览器控制台上打印字符串
使用 console.log() 在浏览器控制台上打印字符串的 length
使用 toUpperCase() 方法将所有字符串字符更改为大写字母
使用 toLowerCase() 方法将所有字符串字符更改为小写字母
使用 substr() 或 substring() 方法切出（切片）字符串的第一个单词
从 30 Days Of JavaScript 中切出短语 Days Of JavaScript。
使用 includes() 方法检查字符串是否包含单词 Script
使用 split() 方法将 string 拆分为 array
使用 split() 方法在空格处拆分字符串 30 Days Of JavaScript
'Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon' 在逗号处 split 字符串并将其更改为数组。
使用 replace() 方法将 30 Days Of JavaScript 更改为 30 Days Of Python。
'30 Days Of JavaScript' 字符串中索引 15 处的字符是什么？使用 charAt() 方法。
使用 charCodeAt() 在 '30 Days Of JavaScript' 字符串中 J 的字符代码是什么
使用 indexOf 确定 30 Days Of JavaScript 中第一次出现 a 的位置
使用 lastIndexOf 确定 30 Days Of JavaScript 中最后一次出现 a 的位置。
使用 indexOf 在以下句子中找到单词 because 第一次出现的位置：'You cannot end a sentence with because because because is a conjunction'
使用 lastIndexOf 在以下句子中找到单词 because 最后一次出现的位置：'You cannot end a sentence with because because because is a conjunction'
使用 search 在以下句子中找到单词 because 第一次出现的位置：'You cannot end a sentence with because because because is a conjunction'
使用 trim() 删除字符串开头和结尾的任何尾随空格。例如 ' 30 Days Of JavaScript '。
对字符串 30 Days Of JavaScript 使用 startsWith() 方法并使结果为 true
对字符串 30 Days Of JavaScript 使用 endsWith() 方法并使结果为 true
使用 match() 方法在 30 Days Of JavaScript 中找到所有 a
使用 concat() 并将 '30 Days of' 和 'JavaScript' 合并为单个字符串，'30 Days Of JavaScript'
使用 repeat() 方法打印 30 Days Of JavaScript 2 次

练习：级别 2

使用 console.log() 打印以下语句：

The quote 'There is no exercise better for the heart than reaching down and lifting people up.' by John Holmes teaches us to help one another.

使用 console.log() 打印 Mother Teresa 的以下引用：

"Love is not patronizing and charity isn't about pity, it is about love. Charity and love are the same -- with charity you give love, so don't just give money but reach out your hand instead."

检查 typeof '10' 是否完全等于 10。如果不是，请使其完全相等。
检查 parseFloat('9.8') 是否等于 10，如果不是，请使其完全等于 10。
检查 'on' 是否在 python 和 jargon 中都找到
I hope this course is not full of jargon。检查 jargon 是否在句子中。
生成 0 到 100 之间的随机数（包括 0 和 100）。
生成 50 到 100 之间的随机数（包括 50 和 100）。
生成 0 到 255 之间的随机数（包括 0 和 255）。
使用随机数访问 'JavaScript' 字符串字符。

使用 console.log() 和转义字符打印以下模式。

1 1 1 1 1
2 1 2 4 8
3 1 3 9 27
4 1 4 16 64
5 1 5 25 125

使用 substr 从以下句子中切出短语 because because because：'You cannot end a sentence with because because because is a conjunction'

练习：级别 3

'Love is the best thing in this world. Some found their love and some are still looking for their love.' 计算这句话中单词 love 的数量。
使用 match() 计算以下句子中所有 because 的数量：'You cannot end a sentence with because because because is a conjunction'

清理以下文本并找到最常见的单词（提示，使用 replace 和正则表达式）。

    const sentence = '%I $am@% a %tea@cher%, &and& I lo%#ve %te@a@ching%;. The@re $is no@th@ing; &as& mo@re rewarding as educa@ting &and& @emp%o@weri@ng peo@ple. ;I found tea@ching m%o@re interesting tha@n any ot#her %jo@bs. %Do@es thi%s mo@tiv#ate yo@u to be a tea@cher!? %Th#is 30#Days&OfJavaScript &is al@so $the $resu@lt of &love& of tea&ching'

通过从以下文本中提取数字来计算该人的年总收入。'He earns 5000 euro from salary per month, 10000 euro annual bonus, 15000 euro online courses per month.'

🎉 恭喜！🎉

<< 第1天 | 第3天 >>

第2天：数据类型 ​

目录 ​

数据类型 ​

原始数据类型 ​

非原始数据类型 ​

数字 ​

声明数字类型 ​

Math 对象 ​

随机数生成器 ​

字符串 ​

字符串连接 ​

长字符串字面量 ​

转义序列 ​

模板字符串 ​

字符串方法 ​

检查数据类型和类型转换 ​

检查数据类型 ​

改变数据类型（类型转换） ​

字符串转整数 ​

字符串转浮点数 ​

浮点数转整数 ​

💻 第 2 天：练习 ​

练习：级别 1 ​

练习：级别 2 ​

练习：级别 3 ​

第2天：数据类型

目录

数据类型

原始数据类型

非原始数据类型

数字

声明数字类型

Math 对象

随机数生成器

字符串

字符串连接

长字符串字面量

转义序列

模板字符串

字符串方法

检查数据类型和类型转换

检查数据类型

改变数据类型（类型转换）

字符串转整数

字符串转浮点数

浮点数转整数

💻 第 2 天：练习

练习：级别 1

练习：级别 2

练习：级别 3