if 多分支语句和 switch的区别:
共同点
区别:
掌握 for 循环语句,让程序具备重复执行能力
for 是 JavaScript 提供的另一种循环控制的话句,它和 while 只是语法上存在差异。
<script>
// 1. 语法格式
// for(起始值; 终止条件; 变化量) {
// // 要重复执行的代码
// }
// 2. 示例:在网页中输入标题标签
// 起始值为 1
// 变化量 i++
// 终止条件 i <= 6
for(let i = 1; i <= 6; i++) {
document.write(`<h${i}>循环控制,即重复执行<h${i}>`)
}
</script>
变化量和死循环,for 循环和 while 一样,如果不合理设置增量和终止条件,便会产生死循环。
跳出和终止循环
<script>
// 1. continue
for (let i = 1; i <= 5; i++) {
if (i === 3) {
continue // 结束本次循环,继续下一次循环
}
console.log(i)
}
// 2. break
for (let i = 1; i <= 5; i++) {
if (i === 3) {
break // 退出结束整个循环
}
console.log(i)
}
</script>
结论:
JavaScript 提供了多种语句来实现循环控制,但无论使用哪种语句都离不开循环的3个特征,即起始值、变化量、终止条件,做为初学者应着重体会这3个特征,不必过多纠结三种语句的区别。for循环,当不明确循环的次数的时候推荐使用while循环注意:
for的语法结构更简洁,故for循环的使用频次会更多。
利用循环的知识来对比一个简单的天文知识,我们知道地球在自转的同时也在围绕太阳公转,如果把自转和公转都看成是循环的话,就相当于是循环中又嵌套了另一个循环。
实际上 JavaScript 中任何一种循环语句都支持循环的嵌套,如下代码所示:
// 1. 外面的循环 记录第n天
for (let i = 1; i < 4; i++) {
document.write(`第${i}天 <br>`)
// 2. 里层的循环记录 几个单词
for (let j = 1; j < 6; j++) {
document.write(`记住第${j}个单词<br>`)
}
}
记住,外层循环循环一次,里层循环循环全部
// 外层打印几行
for (let i = 1; i <= 5; i++) {
// 里层打印几个星星
for (let j = 1; j <= i; j++) {
document.write('★')
}
document.write('<br>')
}
样式css
span {
display: inline-block;
width: 100px;
padding: 5px 10px;
border: 1px solid pink;
margin: 2px;
border-radius: 5px;
box-shadow: 2px 2px 2px rgba(255, 192, 203, .4);
background-color: rgba(255, 192, 203, .1);
text-align: center;
color: hotpink;
}
javascript
// 外层打印几行
for (let i = 1; i <= 9; i++) {
// 里层打印几个星星
for (let j = 1; j <= i; j++) {
// 只需要吧 ★ 换成 1 x 1 = 1
document.write(`
<div> ${j} x ${i} = ${j * i} </div>
`)
}
document.write('<br>')
}
字符串就是零个或多个排在一起的字符,放在单引号或双引号之中
'itbaizhan'
"itbaizhan"
单引号字符串的内部可以使用双引号。双引号字符串的内部,可以使用单引号
'key = "value"'
"It's a long itbaizhan"
如果要在单引号的字符串的内部,使用单引号,就必须在内部的单引号前面加上反斜杠,用来转义。双引号字符串内部使用双引号,也是如此
'Did she say \'Hello\'?'
// "Did she say hello?"
"Did she say \'Hello\'?"
// "Did she say hello?"
字符串默认只能写在一行内,分成多行将会报错
如果长字符串必须分成多行,可以在每一行的末尾使用反斜杠
var longString = 'Long\
long\
string';
longString
// "Long long string"
length属性返回字符串的长度,该属性也是无法改变的
var s = "itbaizhan";
s.length // 9
charAt方法返回指定位置的字符,参数是从0开始编号的
var s = new String('itbaizhan');
s.charAt(1) // "t"
s.charAt(s,length - 1) // "n"
如果参数为负数,或大于等于字符串的长度,charAt返回空字符串
'itbaizhan'.charAt(-1) // ""
'itbaizhan'.charAt(9) // ""
conat方法用于连接两个字符串,返回一个新的字符串,不改变原字符串
var s1 = 'itbaizhan';
var s2 = 'sxt';
s1.concat(s2) // "itbaizhansxt"
s1 // "itbaizhan"
该方法可以接受多个参数
'stx'.concat('itbaizhan', 'bjsxt') // "sxtitbaizhanbjsxt"
如果参数不是字符串, concat方法会将其先转为字符串,然后再连接
var one = 1;
var two = 2;
vat three = '3';
// 123
substring方法用于从原字符串取出子字符串并返回,不改变源字符串,它的第一个参数表示子字符串的开始位置,第二个参数表示结束位置(返回的结果不包含结束位置)
'itbaizhan'.substring(0, 2) // "it"
如果第二个参数省略,则表示子字符串一直到原字符串的结束
'itbaizhan'.substring(2) // "baizhan"
如果第一个参数大于第二个参数,substring方法会自动更换两个参数的位置
'itbaizhan'.subsrting(9, 2) // "baizhan"
// 等同于
'itbaizhan'.sunstring(2, 9) // "baizhan"
如果参数是负数,substring方法会自动将负数转换成0
'itbaizhan'.substring(-3) // "itbaizhan"
'itbaizhan'.substring(2, -3) // "it"
substr方法用于从原字符串中取出子字符串并返回,不改变原字符串跟substring方法的作用相同
substr方法的第一个参数是子字符串的开始位置(从0开始计算),第二个参数是子字符串的长度
'itbaizhan'.substr(2, 7) // baizhan
如果第二个参数省略,则表示子字符串一直到原字符串的结束
'itbaizhan'.substr(2) // baizhan
如果第一个参数是负数,表示倒数计算的字符位置。如果第二个参数是负数,将自动被转为0,因此则会返回空字符串
'itbaizhan',substr(-7) // "baizhan"
'itbaizhan'.substr(4, -1) // ""
indexOf方法用于确定一个字符串在另一个字符串中第一次出现的位置,返回结果是匹配开始的位置。如果返回-1,就表示不匹配
'hello world'.indexOf('o') // 4
'itbaizhan'.indexOf('')
indexOf方法还可以接受第二个参数,表示从该位置开始向后匹配
'hello world'.indexOf('0', 6) // 7
trim方法用于去除字符串两端的空格,返回一个新字符串,不改变原字符串
' hello world '.trim() // "hello world"
该方法去除的不仅是空格,还包括制表符(\t、\v)、换行符(\n)和回车符(\r)
'\r\nitbaizhan \t'.trim() // 'itbaizhan'
ES6扩展方法,trimEnd()和trimStrat方法
" itbaizhan ".trimEnd() // " itbaizhan"
" itbaizhan ".trimStart() // "itbaizhan "
split方法按照给定跪着分割字符串,返回一个由分割出来的子字符串组成的新数组
'it|bai|zhan'.split('|') // ["it","bai","zhan"]
如果分割规则为空字符串,则返回数组的成员是原字符串的每一个字符。
'a|b|c'.split("") // ["a","b","c"]
如果省略参数,则返回数组的唯一成员就是原字符串
'it|bai|zhan'.split() // [is|bai|zhan]
split方法还可以接受第二个参数,限定返回数组的最大成员数
'it|bai|zhan'.split('|', 0) // []
'it|bai|zhan'.split('|', 1) // ["it"]
'it|bai|zhan'.split('|', 2) // ["it","bai"]
'it|bai|zhan'.split('|', 3) // ["it","bai","zhan"]
'it|bai|zhan'.split('|', 4) // ["it","bai","zhan"]
知道什么是数组及其应用的场景,掌握数组声明及访问的语法。
数组:(Array)是一种可以按顺序保存数据的数据类型
**使用场景:**如果有多个数据可以用数组保存起来,然后放到一个变量中,管理非常方便
<script>
// 1. 语法,使用 [] 来定义一个空数组
// 定义一个空数组,然后赋值给变量 classes
// let classes = [];
// 2. 定义非空数组
let classes = ['小明', '小刚', '小红', '小丽', '小米']
</script>
通过 [] 定义数组,数据中可以存放真正的数据,如小明、小刚、小红等这些都是数组中的数据,我们这些数据称为数组单元,数组单元之间使用英文逗号分隔。
使用数组存放数据并不是最终目的,关键是能够随时的访问到数组中的数据(单元)。其实 JavaScript 为数组中的每一个数据单元都编了号,通过数据单元在数组中的编号便可以轻松访问到数组中的数据单元了。
我们将数据单元在数组中的编号称为索引值,也有人称其为下标。
索引值实际是按着数据单元在数组中的位置依次排列的,注意是从 0 开始的.
<script>
let classes = ['小明', '小刚', '小红', '小丽', '小米']
// 1. 访问数组,语法格式为:变量名[索引值]
document.write(classes[0]) // 结果为:小明
document.write(classes[1]) // 结果为:小刚
document.write(classes[4]) // 结果为:小米
// 2. 通过索引值还可以为数组单重新赋值
document.write(classes[3]) // 结果为:小丽
// 重新为索引值为 3 的单元赋值
classes[3] = '小小丽'
document.wirte(classes[3]); // 结果为: 小小丽
</script>
数组做为数据的集合,它的单元值可以是任意数据类型
<script>
// 6. 数组单值类型可以是任意数据类型
// a) 数组单元值的类型为字符类型
let list = ['HTML', 'CSS', 'JavaScript']
// b) 数组单元值的类型为数值类型
let scores = [78, 84, 70, 62, 75]
// c) 混合多种类型
let mixin = [true, 1, false, 'hello']
</script>
重申一次,数组在 JavaScript 中并不是新的数据类型,它属于对象类型。
<script>
// 定义一个数组
let arr = ['html', 'css', 'javascript']
// 数组对应着一个 length 属性,它的含义是获取数组的长度
console.log(arr.length) // 3
</script>
for (let i = 0;i<数组名.length; i++) {
console.log(数组名[i]);
}
let i = 0;
while (i < 数组名.length) {
console.log(数组名.[i]);
}
let a = [`a` , `b`, `c`];
for (let i in a) {
console.log(a) // 拿到索引
console.log(a[i]) // 通过索引拿到值
}
let a = [`a` , `b`, `c`];
for (let i of a) {
console.log(a) //直接拿到值
}
arr.forEach((item, index) => {
console.log('值:', item, '索引:', index);
});
const newArr = arr.map(item => item * 2);
// [1,2,3] → [2,4,6]
const res = arr.filter(item => item > 15);
// [10,20,30] → [20,30]
// 求和
const sum = arr.reduce((total, item) => total + item, 0);
方法返回一个布尔值,表示参数是否为数组。它可以弥补typeof运算符的不足。
var arr =["尚学堂",100,true];
console.log(typeof arr);// object
var arr = ['sxt', 'baizhan', 'it'];
Array.isArray(arr)//true
push方法用于在数组的末端添加一个或多个元素,并返回添加新元素后的数组长度。注意,该方法会改变原数
组
var arr = [];
arr.push("尚学堂") //1
arr.push('itbaizhan')//2
arr.push(true,{)//4
arr//[尚学堂,'itbaizhan',true,{}]
pop方法用于删除数组的最后一个元素,并返回该元素。注意,该方法会改变原数组
Var arr=['尚学堂','itbaizhan',‘wEB前端'];
arr.pop()//‘wEB前端
arr//['尚学堂'itbaizhan']
shift方法用于删除数组的第一个元素,并返回该元素。注意,该方法会改变原数组
var arr=['尚学堂','itbaizhan','WEB前端'];
arr.shift(//'尚学堂‘
arru['itbaizhan',‘wEB前端']
shift方法可以遍历并清空一个数组
var list =[1,2,3,4,5,6];
var item;
while (item = list.shiftO){ //取布尔值
console.log(item);
list // []
unshit方法用于在数组的第一个位置添加元素,并返回添加新元素后的数组长度。注意,该方法会改变原数组
var arr=['尚学堂,‘itbaizhan',‘wEB前端'];
3 arr.unshift('baizhan');// 4
4arr//['baizhan',‘尚学堂','itbaizhan',‘wEB前端']
unshit方法可以接受多个参数,这些参数都会添加到目标数组头部
var arr =['尚学堂','itbaizhan'];
2arr.unshift('wEB前端','baizhan')// 4
3arr//[‘wEB前端',‘baizhan',‘尚学堂','itbaizhan']
join方法以指定参数作为分隔符,将所有数组成员连接为一个字符串返回。如果不提供参数,默认用逗号分隔
var a = [1, 2, 3,4];
a.join('')//'123 4"
a.join('|')//"1丨2|3|4"
a.join()//"1,2,3,4”
如果数组成员是undefined或null或空位,会被转成空字符串
[undefined,null].join('#')
// `#`
['a',,'b'].join('-')
//'a--b
数组的join配合字符串的split可以实现数组与字符串的互换
var arr=["a","b","c"];
var myArr = arr.join(" ");
console.log(myArr);// [a b c]
console.log(myArr.split(" "));
console.log(myArr);// ["a","b","c"]
concat方法用于多个数组的合并。它将新数组的成员,添加到原数组成员的后部,然后返回一个新数组,原数
组不变
['hello'].concat(['world'])
// ["hello", "world"]
['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]
除了数组作为参数,concat也接受其他类型的值作为参数,添加到目标数组尾部。
[1,2,3].concat(4,5,6)
[1, 2,3,4, 5, 6]
应用场景 上拉加载,合并数据
reverse方法用于颠倒排列数组元素,返回改变后的数组。注意,该方法将改变原数组
var a = ['a','b','c'];
a.reverseO // ["c","b","a"]
a // ["c","b","a"]
实现一个字符串反转排列
var str = "hello";
2str.split("").reverse(.join("")
indexOf方法返回给定元素在数组中第一次出现的位置,如果没有出现则返回 -1
var arr =['a','b','c'];
arr.indexof('b')// 1
arr.indexof('y')//-1
indexof方法还可以接受第二个参数,表示搜索的开始位置
['尚学堂',‘百战程序员','itbaizhan'].indexof('尚学堂',1) // -1
lastIndexOf从尾部倒着找最后一个匹配下标
let arr = [10,20,30,20];
arr.lastIndexOf(20); // 3
判断数组是否存在该元素,返回布尔
true/false
let arr = [10,20,30,20];
arr.includes(30); // true
find:遍历数组,返回第一个满足条件的元素本身
let arr = [10,20,30,20];
arr.find(item => item > 15); // 20
findIndex:返回第一个满足条件元素的索引
let arr = [10,20,30,20];
arr.findIndex(item => item > 15); // 1
every:每一项都满足条件才为 true(全过才 true,全真校验)
let arr = [10,20,30,20];
arr.every(item => item > 0); // true
some:只要任意一项满足条件就为 true(有一个就行)
let arr = [10,20,30,20];
arr.some(item => item > 50); // false
let arr = [3,1,4,2];
arr.sort((a,b) => a - b);
// 升序:[1,2,3,4]
a - b:小的排前面 → 从小到大升序arr.sort((a,b) => b - a);
// 降序:[4,3,2,1]
b - a:大的排前面 → 从大到小降序切记:
原生 sort() 默认按字符串 Unicode 排序,纯数字不写回调会乱序,必须传 (a,b)=>a-b!
例:[10,2].sort() 错误 → [10,2]
splice(起始索引, 删除个数, 插入内容…)修改原数组,可增 / 删 / 替换三合一
let arr = [0,1,2,3,4];
arr.splice(2, 0, 'a');
console.log(arr); // [0,1,'a',2,3,4]
2:从索引 2开始0:删除 0 个元素let arr = [1,2,3,4,5];
// 删除指定索引元素(索引1,删除1个)
arr.splice(1, 1); // [1,3,4,5]
let arr = ['a','b','c'];
// 从索引零开始,删除两个元素,插入x,y
arr.splice(0,2,'x','y'); // ['x','y,'c']
正在加载评论...