# HTML、CSS、JS

HTML

标记、元素、属性、注释

# 标记/标签
HTML中,用于描述功能的符号称为标记,也叫标签。例如`<p>``<h1>`
  + 标记在使用时必须使用尖括号`<>`括起来。
  + 封闭类标记/双标记:标记必须成对出现。
	`<标记>内容</标记>`
  + 非封闭类标记/单标记/空标记
	`<标记>``<标记/>`

# 元素
  + 元素是标记中每一对尖括号包围的部分。
  + 元素可以包含文本内容和其它元素,也可以是空的。
  + 元素可以相互嵌套,形成更为复杂的语法,但需注意标记的嵌套顺序。

# 属性和值
  + 属性是用来修饰元素的。
	属性的声明必须位于开始标记里。
	一个元素的可以有多个属性,多属性之间用'空格'隔开。
	多属性之间不区分先后顺序。
  + 每个属性都有值。
	属性和属性的值之间用'等号'连接。
	属性的值包含在引号内。
	`属性='值'``属性="值"`
  + 标准属性/通用属性
    每个元素都有自己所特有的属性。
    有些属性是绝大多数元素都支持的属性,称为标准属性或通用属性。例如,id、title、class、style

# 示例
<元素 属性1="值" 属性n="值">文本或嵌套元素</元素>
<元素 属性1="值" 属性n="值"><元素 属性1="值" 属性n="值"/>

# HTML注释
  + 语法:<!-- 注释内容 -->
  + pycharm中注释方式:
	【Ctrl + /】,批量注释,每行单独注释
	【Ctrl + Shift + /】,批量注释,一个注释符号

HTML文档

结构

<!DOCTYPE html>
<html>                    <!--指html页面-->
<head> .... </head>       <!--定义html页面的全局信息,例如:标题,函数,类型等-->
<body> .... </body>       <!--定义html页面的主体内容,即正文-->
</html>

示例:
<!DOCTYPE html>                  <!--声明文档类型,为HTML文件-->
<html lang="en">                 <!--html根元素-->
<head>                           <!--定义HTML页面的全局信息-->
    <meta charset="UTF-8">
    <title>我的站点</title>       <!--网页标题-->
</head>
<body>                           <!--定义HTML页面的主体内容-->
    Hello a! <br>Hello b!    	 <!--单标记<br>用于换行-->
	<p>Hello c!</p>				 <!--双标记<p>用于添加段落元素-->
</body>
</html>

head 元素

# <head></head>之间的元素
<meta>				# 元数据
<title></title>		# 标题
<style></style>		# 设置样式。CSS,用于控制样式,在body中被调用
<script></script>	# 定义函数。JS,用于控制交互与行为,在body中被调用
					# 注意:JS的函数名不能取名click

HTML、CSS、JS

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>我的站点</title>
    <!--CSS在head里面定义,用于控制样式,在body中被调用-->
    <!--style用于设置样式-->
    <style>
        p {
            text-align: center;
            color: red;
        }
    </style>
    <!--JS在head里面定义,用于控制交互与行为,JS的函数名不能取名click-->
    <!--script用于定义脚本,function定义函数-->
    <script>
        function clickme() {
            alert('How are you?');
        }
    </script>
</head>
<body>
	<!--p用于定义段落-->
    <p>这是一个段落</p>
    <p>
    	<button>这是一个按钮</button>
    </p>
    <p>
        <!--button用于定义按钮;onclick只点击时,会自动切换到函数clickme()-->
        <button onclick="clickme()">点我</button>
    </p>
</body>
</html>

文本和样式

文本常用标记

# 文本
+ 直接键入的文本会用浏览器默认的样式显示
+ 包含在标记中的文本会被显示为标记所拥有的样式

# 内置样式
    # 块级元素:结束标记会换行
    `<h1>一级标题</h1>`
    `<h2>二级标题</h2>`
    `<h3>三级标题</h3>`
    `<h4>四级标题</h4>`
    `<h5>五级标题</h5>`
    `<h6>六级标题</h6>`
    `<p>整段内容</p>`		# 分段标记,有上下边距
    `<div>整块内容</div>`	# 块标记,没有上下边距
    # 行内元素:换行需要使用换行符
    `<strong>加粗</strong>`
    `<b>粗体</b>`
    `<i>斜体</i>`
    `<u>下划线</u>`
    `<s>删除线</s>`
    `<span>内容</span>`	# 行内分区标记
    # 单标记
    `<br>`					# 换行,单标记,break
    `<hr>`					# 水平线,单标记,horizontal rule

# 文本的特殊字符
    `&nbsp;`	# 单个空格
                # 在文本中直接键入多个空格或制表符会压缩成单个空格,即只显示一个空格
    `&copy;`	# 版权符号
    `&lt;`		# 小于号
    `&gt;`		# 大于号
    `<sup>上标内容</sup>`	# 上标
    `<sub>下标内容</sub>`	# 下标

# 自定义样式
	`<span class=自定义样式名>修饰内容<span/>`	# 使用自定义样式修饰内容

常用内置样式示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>内置样式示例</title>
</head>
<body>
<h1>测试 test1</h1>       <!--h1 表示一级标题-->
<h2>测试 test2</h2>       <!--h2 表示二级标题-->
<h3>测试 test3</h3>       <!--h3 表示三级标题-->
<h4>测试 test4</h4>       <!--h4 表示四级标题-->
<h5>测试 test5</h5>       <!--h5 表示五级标题-->
<h6>测试 test6</h6>       <!--h6 表示六级标题-->
    <hr>				 <!--hr 水平线-->
<p>                      <!--p 分段标记,有上下边距-->
    测试 test<br>			    <!--br 换行符 -->
    <strong>测试 test</strong> <br> 	<!--strong 加粗-->
    <b>测试 test</b> <br>    		<!--b 粗体-->
    <i>测试 test</i> <br>    		<!--i 斜体-->
    <u>测试 test</u> <br>    		<!--u 下划线-->
    <s>测试 test</s> <br>    		<!--s 删除线-->
</p>
	<hr>
<div>					 <!--div 分区标记,没有上下边距-->
	测试   test <br>           <!--直接键入多个空格或制表符会只显示一个空格-->
    测试&nbsp;&nbsp;&nbsp;test <!--&nbsp; 浏览器可识别的单个空格-->
</div>
<div>
    &copy; 版权所有:xxx公司<br>	   <!--&copy; 版权符号-->
    书名:&lt;时间简史&gt;<br>		   <!--&lt; 小于 &gt; 大于 -->
    2<sup>3</sup> = 8 <br>		   <!--sup 上标-->
    log<sub>2</sub>8 = 3      	   <!--sub 下标-->
</div>
    <hr>
</body>
</html>

自定义样式示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>自定义样式示例</title>
    <!--style定义内嵌样式,使用class选择器.c1-->
    <style>
        .c1 {
            color: darkred;
        }
        .c2 {
            color: green;
        }
    </style>
</head>
<body>
        测试 <span class="c1">test</span> 测试<br>
        测试 <span class="c2">test</span> 测试
</body>
</html>

图像、链接、表格、列表、表单

图像 <img>

图像常用属性
`<img src='图片路径' 属性2='值' 属性n='值'>`		# 显示图片
<img>常用属性:
	src='图片路径'		# 绝对路径或相对路径
	height='100px'
	width='100px'	
		# 注意:单用height或width时,会等比例缩放。同时使用时,图像可能变形
	alt='图像无法显示时,显示的文字'
	id='值'			# 给<img>设置一个唯一的id
图像示例
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>图像</title>
</head>
<body>
<div>
    <img src="https://test.com/panda.jpg">
</div>
<div>
    <img src="imgs/panda.jpg">
</div>
<div>
    <img src="imgs/dogs.jpg" alt="图像无法显示时,显示的文字">
</div>
<div>
    <img src="imgs/panda.jpg" height="100px">   <!--height设置高度,等比缩放-->
    <hr>
    <img src="imgs/panda.jpg" width="100px">    <!--width设置宽度,等比缩放-->
    <hr>
    <img src="imgs/panda.jpg" height="100px" width="100px"> <!--同时设置宽高会变形-->
</div>
</body>
</html>

链接 <a> </a>

链接常用属性
`<a href='链接路径' target='打开方式' >显示内容或元素</a>`	# 点击内容或元素跳转到href的链接
<a></a>常用属性:
	href='链接路径'
		'绝对URL路径'		# 例如"http://www.baidu.com"
		'相对URL路径'		# 例如"/music"实际是"http://ip:端口/music"
		'#元素id值'	    # 跳转到元素
		'#'				# 跳转到顶部
		''				# 刷新页面
	target='目标打开位置'
		'_self'			# (缺省)在当前页打开目标链接
		'_blank'		# 在空白页打开目标链接
链接示例
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>链接</title>
</head>
<body>
<div>
    <a href="https://www.baidu.com">百度</a>	
    					<!--缺省target="_self",在当前页打开目标链接-->
    <hr>
    <a href="https://www.jd.com", target="_blank">京东</a> 
    					<!--target="_blank",在空白页打开目标链接-->
</div>
<div>
    <!--也可以点击图像跳转-->
    <a href="https://www.baidu.com" target="_blank">
        <img src="imgs/panda.jpg" height="100px">
    </a>
</div>
    <a href="#id_1">跳转到图片猫</a>    <!--href='#图片id值',跳转特定的元素-->
    <hr>
    <a href="#">返回顶部</a>		    <!--href='#',跳转顶部-->
    <hr>
    <a href="">刷新页面</a>			    <!--href='',刷新页面-->
</div>
</div>
    <img id="id_1" src="imgs/cat.jpg" height="100px">
						<!--id='值',标记元素-->
</div>
</body>
</html>

表格 <table> </table>

表格常用属性
# 快捷创建:
	table>tr*3>td*2,tab键
# 示例:
<table>
	<thead>
        <tr>
            <td>单元格内容</td>
            <td>单元格内容</td>
        </tr>
	</thead>
	<tbody>
        <tr>
            <td>单元格内容</td>
            <td>单元格内容</td>
        </tr>
        <tr>
            <td>单元格内容</td>
            <td>单元格内容</td>
        </tr>
	</tbody>
	<tfoot>
        <tr>
            <td>单元格内容</td>
            <td>单元格内容</td>
        </tr>
	</tfoot>
</table>

# 单元格默认 align='left' 和 valign='middle'

`<table 属性1='值' 属性n='值'></table>`
<table></table>常用属性:
    align		# 设置表格对齐方式(left | center | right)
    valign		# 设置垂直对齐方式(top | middle | bottom)
    width		# 设置表格宽度
    height		# 设置表格高度
    border		# 设置表格边框宽度
    cellpadding	# 设置内边距(单元格边框与内容之间的距离)
    cellspacing	# 设置外边距(单元格之间的距离)
    bgcolor		# 设置表格背景颜色

`<tr 属性1='值' 属性n='值'></tr>`
<tr></tr>常用属性
    align		# 设置水平对齐方式(left | center | right)
    valign		# 设置垂直对齐方式(top | middle | bottom)
    width		# 设置宽度
    height		# 设置高度

`<td 属性1='值' 属性n='值'>单元格内容</td>`
<td></td>常用属性
    align		# 设置水平对齐方式(left | center | right)
    valign		# 设置垂直对齐方式(top | middle | bottom)
    width		# 设置宽度
    height		# 设置高度
    colspan		# 设置单元格跨列,向右合并单元格个数
    rowspan		# 设置单元格跨行,向下合并单元格个数

# 同属性优先级 
td > tr > table

# 头部、主体、脚部
<thead></thead>
<tbody></tbody>
<tfoot></tfoot>
表格示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>表格</title>
</head>
<body>
    <!--跨行、跨列-->
    <table border="1px" width="400px">		<!--border表格边框宽度,width表格宽度-->
        <tr>
            <td colspan="2" align="center" height="50px" width="200px">课程</td>
                                            <!--colspan="2"向右合并两个单元格-->
            <td>分数</td>
        <tr height="50px">
            <td rowspan="4" width="80px">张三</td>	   
            								<!--rowspan="4"向下合并四个单元格-->
            <td>语文</td>
            <td>xxx</td>
        </tr>
        <tr height="50px">
            <td>数学</td>
            <td>yyy</td>
        </tr>
        <tr height="50px">
            <td>英文</td>
            <td>zzz</td>
        </tr>
    	<tr height="50px">
            <td colspan="2">A</td>
        </tr>
        <tr height="50px">
            <td rowspan="4">李四</td>
            <td align="left">语文</td>		<!--align="left"-->
            <td valign="top">xxx</td>			<!--valign="top"-->
        </tr>
        <tr height="50px" align="right">
            <td align="center">数学</td>		<!--align="center"-->
            <td valign="middle">yyy</td>		<!--valign="middle"-->
        </tr>
        <tr height="50px">
            <td align="right">英文</td>		<!--align="right"-->
            <td valign="bottom">zzz</td>		<!--valign="bottom"-->
        </tr>
    	<tr height="50px">
            <td colspan="2">B<br>C</td>
        </tr>
    </table>

    <!--头部、主体部分、脚部-->
    <table border="1px" width="200">
        <thead>					<!--thead头部-->
            <tr>
                <th>日期</th>
                <th>支出</th>
            </tr>
        </thead>
        <tbody>					<!--tbody主体部分-->
            <tr>
                <td>1-16</td>
                <td>100</td>
            </tr>
            <tr>
                <td>1-17</td>
                <td>160</td>
            </tr>
        </tbody>
        <tfoot>					<!--tfoot脚部-->
            <tr>
                <td>总计</td>
                <td>260</td>
            </tr>
        </tfoot>
    </table>
</body>
</html>

列表 <ol> </ol> <ul> </ul>

列表常用属性
# 快捷创建:
	有序列表 ol>li*3,tab键
	无序列表 ul>li*3,tab键
# 示例:
<ol>
	<li>列表元素1</li>
	<li>列表元素2</li>
	<li>列表元素3</li>
</ol>
<ul>
	<li>列表元素1</li>
	<li>列表元素2</li>
	<li>列表元素3</li>
</ul>

`<ol 属性1='值' 属性n='值'></ol>`
<ol></ol>常用属性:
	type			# 序号类型。缺省使用数字排序
		'A'			# 使用大写英文字母排序
		'I'			# 使用罗马数字排序
	start			# 序号起始位置
		'5'			# 使用序号类型的第五个符号开始排序

`<ul 属性1='值' 属性n='值'></ul>`
<ul></ul>常用属性:
	type			# 序号类型。缺省为实心圆点
		'circle'	# 空心圆点
		'square'	# 实习方块
列表示例

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>列表</title>
</head>
<body>
    <!--ol有序列表-->
    <ol>					<!--缺省type='1'-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ol>
    <ol type="A">			<!--type='A'使用大写英文字母排序-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ol>
    <ol type="A" start="5">	<!--start='5'使用序号类型的第五个符号开始排序-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ol>
    <ol type="I" start="3">	<!--type='I'使用罗马数字排序-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ol>
    <hr>
    <!--ul无序列表-->
    <ul>
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ul>
    <ul type="circle">    	<!--type="circle"使用小圆圈-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ul>
    <ul type="square">    	<!--type="square"使用实体方块-->
        <li>张三</li>
        <li>李四</li>
        <li>王五</li>
    </ul>
</body>
</html>

表单 <form></form>

表单元素属性
# 表单
1. 表单用于显示、收集信息,并提交信息到服务器。有两个基本部分:
	实现数据交互的可见的界面元素
	提交后的表单处理
2. 表单元素`<form></form>`
3. 表单可以包含很多不同类型的表单控件,表单控件元素只有在表单元素`<form></form>`中才能发挥作用
4. 表单控件元素有:
	input元素:输入框(文本框、密码框、隐藏控件)、选择框(单选框、复选框)、按钮(提交按钮、重置按钮、普通按钮)
	select和option元素
	textarea元素
	其它元素
	
	
表单元素`<form 属性1="值" 属性n="值"></form>`
<form></form>常用属性
	action="URL地址"	# 点击提交键后,键值对将提交到"URL地址?键1=值1&键n=值n"
						# 缺省action="",实际是"当前URL"
						# 相对URL路径action="/music",实际是"http://ip:端口/music"
	target='目标打开位置'
		'_self'			# (缺省)在当前页打开目标"url?键1=值1&键n=值n"
		'_blank'		# 在空白页打开目标"url?键1=值1&键n=值n"
	name="表单名称"
	method="表单数据提交方式"		# 取值为 get 或者 post
	enctype="表单数据进行编码的方式"
<input> 常用属性
表单控件元素`<input type="值" 属性2="值" 属性n="值">`
单标记<input>常用属性
# 按钮
  + 提交按钮。传送表单数据,将text、password、hidden的键值对值赋予form的属性action指定的url路径
	<input type="submit" value="按钮的文字">
  + 重置按钮。清空表单的内容并把所有表单控件设置为最初的默认值。缺省value="重置"
	<input type="reset" value="按钮的文字">
  + 普通按钮。用于执行脚本
	<input type="button" value="按钮的文字">
# 输入框
  + 文本框。显示明文,用于获取值
    <input type="text" name="被赋值的键" placeholder="提示信息" maxlength="最大字符数">
  + 密码框。不显示明文,用于获取值
	<input type="password" name="被赋值的键" placeholder="提示信息" maxlength="最大字符数">
  + 隐藏输入框。直接用于设置键值对
	<input type="hidden" name="隐藏赋值的键" value="赋予的值">
# 选择框
  + 单选框。同一组单选框的name相同。checked预选中
	<input type="raido" name="被赋值的键" value="赋予的值" checked>
  + 复选框。同一组复选框的name相同。checked预选中
	<input type="checkbox" name="被赋值的键" value="赋予的值" checked>

# <label></label>将文本与选择控件(单选框/复选框)绑定,点击文本跟点击选择控件作用一样
# 写法一
<label>
	<input type="radio" name="键" value="值">
	文本
</label>
# 写法二,id值在同一个html中唯一
<input id="id值" type="radio" name="键" value="值">
<label for="id值">
	文本
</label>
<input> 示例之输入框

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>输入框</title>
</head>
<body>
    <form><!--缺省action=""当前页url,缺省target="_self"在当前页打开目标"url?键1=值1&键n=值n"-->
        <p>
        user: <input type="text" placeholder="用户名"><br>
        					<!--type="text"文本框显示明文,placeholder="提示信息"-->
        pass: <input type="password" placeholder="密码"><br>
        					<!--type="password"密码框不显示明文,placeholder="提示信息"-->  
        </p>
        <input type="submit" value="登 陆">
        					<!--type="submit"提交按钮,value="按钮的文字"-->
        <!--点击提交按钮,将text、password、hidden的键值对值赋予form的属性action指定的url路径-->
        <input type="reset">
        					<!--type="reset"重置按钮,缺省value="重置"-->
    </form>
<hr>
    <!--实现https://www.sogou.com/web?query=cat-->
    <form action="https://www.sogou.com/web" target="_blank">
							<!--target="_blank"在空白页打开目标"url?键1=值1&键n=值n"-->
        <input type="text" name="query">
							<!--type="text"或type="password",name="键"-->
        <input type="submit" value="搜狗搜索">
    </form>
<hr>
    <!--实现https://images.baidu.com/search/index?tn=baiduimage&word=cat-->
    <form action="https://images.baidu.com/search/index" target="_blank">
        <input type="hidden" name="tn" value="baiduimage">
        					<!--type="hidden"隐藏输入框直接输入键值对,name="键",value="值"-->
        <input type="text" name="word">
        <input type="submit" value="百度搜图">
    </form>
</body>
</html>
<input> 示例之选择框 <label></label>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>选择框</title>
</head>
<body>
<!--label 将文本与选择控件绑定,点击文本跟点击选择控件作用一样-->    
    <form>
		<!--type="radio"单选框,同一组单选框的name相同-->
        <p>1. 性别?</p>
        <!--写法一-->
        <label>
            <input type="radio" name="q1" value="A">
            A. 男
        </label><br>
        <!--写法二-->
        <input id="id_2" type="radio" name="q1" value="B">
        <label for="id_2">B. 女</label>

        <!--type="checkbox"多选框-->
        <p>2. 爱好有哪些?</p>
        <input id="1" type="checkbox" name="q2" value="A">
		<label for="1">A. 爬山</label><br>
        <input id="2" type="checkbox" name="q2" value="B">
        <label for="2">B. 看戏</label><br>
        <input id="3" type="checkbox" name="q2" value="C">
        <label for="3">C. 远足</label><br>
        <input id="4" type="checkbox" name="q2" value="D">
        <label for="4">D. 游泳</label>
		<p><input type="submit"></p>
	</form>
</body>
</html>
<select></select> 下拉列表 <option></option>
# 下拉列表
# 快捷创建:
	select>option*3,tab键
# 示例:
<select name="被赋值的键">							# 缺省size="1",下拉选项框
	<option value="赋予的值">选项1</option>
	<option value="赋予的值" selected>选项2</option>	# selected预选中
	<option value="赋予的值">选项3</option>
</select>

<select name="被赋值的键" size="3">					# size大于1,滚动列表
	<option value="赋予的值">选项1</option>
	<option value="赋予的值" selected>选项2</option>	# selected预选中
	<option value="赋予的值">选项3</option>
</select>

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>下拉列表</title>
</head>
<body>
    <form>
        <!--select下拉列表,option下拉列表的元素-->
        <p>3. 爱好有哪些?</p>
        <!--缺省size="1",下拉选项框-->
        <select name="q3">
            <option value="A"> A. 爬山</option>
            <option value="B"> B. 看戏</option>
            <option value="C"> C. 远足</option>
            <option value="D"> D. 游泳</option>
            <option value="E" selected> E. 跑步</option>
            						<!--value="值",selected预选中-->
        </select>
        
        <!--size大于1,滚动列表-->
        <p>4. 爱好有哪些?</p>
        <select name="q4" size=3>
            <option value="A"> A. 爬山</option>
            <option value="B"> B. 看戏</option>
            <option value="C"> C. 远足</option>
            <option value="D"> D. 游泳</option>
            <option value="E" selected> E. 跑步</option>
        </select>
        <p><input type="submit"></p>
    </form>
</body>
</html>
<textarea></textarea> 多行文本框
# 多行文本框
	<textarea name="被赋值的键" cols="文本框宽度" rows="文本框高度">预输入内容</textarea>

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>多行文本框</title>
</head>
<body>
    <form>
		<!--textarea多行文本框-->
        <textarea name="comment" cols="50" rows="5">请输入内容</textarea> <br>
        						<!--name="键",cols="文本框宽度",rows="文本框高度"-->
        <input type="submit" value="发表">
    </form>
</body>
</html>

CSS

CSS(Cascading Style Sheets,层叠样式表)

# CSS与HTML
HTML用于定义内容的结构和语义,CSS用于设计风格和布局。
可以通过三种方式在HTML中使用CSS:
    1. 内联样式
        + 通过属性style定义样式,并直接写入现有的HTML标签
            style="属性1:值;属性n:值;"
        + 缺点:CSS和HTML标签,标签使用样式都需要定义一次
    2. 内嵌样式
        + 借助标签<style></style>定义样式,并写入HTML的<head>之间
            <style>				# 缺省<style type="text/css">
                选择器 {
                    属性1: 值;
                    属性n: 值;
                }
            </style>
        + 优点:实现CSS和HTML标签的分离
    3. 外链样式/外联式
        + 将CSS样式写入一个.css文件,借助标签<link/>链接.CSS文件,并写入HTML的<head>之间
            <link rel="stylesheet" href=".css文件路径">
        + 优点:实现CSS文件和HTML文件的解耦

# CSS注释语法
/* 注释内容 */
/* 
	注释内容
	注释内容
*/

CSS常用属性

# CSS常用属性:
    background-color	 # 背景颜色
    color				# 字体颜色
    font-size			# 字体大小
    text-align			# 文本水平对齐方式。left | center | right
    display				# 显示区域。block | inline

HTML使用CSS的三种方式

在这里插入图片描述

内联样式 style="属性1:值;属性n=值"

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS内联样式</title>
</head>
<body>
    <h1 style="background-color:red;color:white;font-size:40px;text-align:center;">
        测试1test
    </h1>
    <h1 style="background-color:red;color:white;font-size:40px;text-align:center;">
        测试2test
    </h1>
</body>
</html>

内嵌样式 <style>选择器{属性1:值;属性n:值;}</style>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS内嵌样式</title>
    <style>
        h1 {
            background-color: red;
            color: white;
            font-size: 40px;
            text-align: center;
        }
    </style>
</head>
<body>
    <h1>测试1test</h1>
    <h1>测试2test</h1>
</body>
</html>

外链样式 <link rel="stylesheet" href=".css文件路径">

]# cat css/h1.css
h1 {
    background-color: red;
    color: white;
    font-size: 40px;
    text-align: center;
}

]# cat test.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>CSS外链样式</title>
    <link rel="stylesheet" href="css/h1.css"/>
</head>
<body>
    <h1>测试1test</h1>
    <h1>测试2test</h1>
</body>
</html>

CSS 选择器

选择器种类

# CSS选择器
根据查找元素的方式不同,可以分为以下几类:
    标签选择器
    class选择器		# 一个class可以被多个标签复用
    id选择器			# 一个id只能被一个标签使用
    群组选择器			# `标签1,标签2,标签n {}`
    后代选择器
    子代选择器
    伪类选择器

# 以下示例均使用内嵌样式展示

标签选择器 标签名{}

在这里插入图片描述

/* 标签选择器 */
/* 
	标签选择器在HTML使用标签时会自动调用。 
*/

标签名 {
    属性:;
    属性:;
}

* {						/* *代表所有标签 */
    属性:;
    属性:; 
}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>标签选择器</title>
    <style>
        h1 {
            background-color: pink;
            color: blue;
            font-size: 40px;
            text-align: center;
        }
    </style>
</head>
<body>
    <h1>测试1test</h1>
    <h1>测试2test</h1>
</body>
</html>

class选择器 .class名{} 共享

在这里插入图片描述

/* class选择器 */
/*
    class选择器需要在HTML标签内使用属性class手动选择。
    一个class可以被多个标签复用
*/

.class名 {
    属性:;
    属性:;
}

标签使用class属性的快捷方式
	标签名.class名,tab键
标签使用id属性和class属性快捷方式
	标签名#id名.class名,tab键
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>class选择器</title>
    <style>
        .c1 {
            background-color: pink;
            color: blue;
            font-size: 40px;
            text-align: center;
        }
    </style>
</head>
<body>
    <h1 class="c1">测试1test</h1>		<!-- 一个class可以被多个标签复用-->
    <h1 class="c1">测试2test</h1>
</body>
</html>

id选择器 #id名{} 独享

在这里插入图片描述

/* id选择器 */
/* 
	id选择器需要在HTML标签内使用属性id手动选择
	一个id只能被一个标签使用
*/

#id名 {
    属性:;
    属性:;
}

标签使用id属性的快捷方式
	标签名#id名,tab键
标签使用id属性和class属性快捷方式
	标签名#id名.class名,tab键
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>id选择器</title>
    <style>
        #i1 {
            background-color: pink;
            color: blue;
            font-size: 40px;
            text-align: center;
        }
        #i2 {
            background-color: pink;
            color: blue;
            font-size: 40px;
            text-align: center;
        }
    </style>
</head>
    <body>
    <h1 id="i1">测试1test</h1>	<!-- 一个id只能被一个标签使用-->
    <h1 id="i2">测试1test</h1>
    </body>
</html>

后代选择器 标签 后代标签{}

/* 后代选择器 */

标签1 标签2{		/* 当标签2是标签1的后代时,样式生效。标签2会集成标签1的样式 */
	属性:;
}

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>后代选择器</title>
    <style>
        p {
            color: red;
        }
        span {
            color: blue;
        }
        div p {
            color: darkred;
        }
        div span {
            color: green;
        }
    </style>
</head>
<body>
    <p>
        测试<br>					<!--p非div后代:使用p,red-->
        <span>测试</span>			<!--span非div后代:使用span,blue-->
    </p>
    <div>
        <p>
            测试<br>				<!--p是div后代:使用div p,darkred-->
            <span>测试</span>		<!--span是div后代:使用div span,green-->
        </p>
        <span>测试</span>			<!--span是div后代:使用div span,green-->
    </div>
</body>
</html>

子代选择器 标签 > 子代标签{}

/* 子代标签 */

标签1 > 标签2{		/* 当标签2是标签1的直接子代时,样式生效。标签2会集成标签1的样式 */
	属性:;
}

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>后代选择器</title>
    <style>
        p {
            color: red;
        }
        span {
            color: blue;
        }
        div > p {
            color: darkred;
        }
        div > span {
            color: green;
        }
    </style>
</head>
<body>
    <p>
        测试<br>					<!--p非div后代:使用p,red-->
        <span>测试</span>			<!--span非div后代:使用span,blue-->
    </p>
    <div>
        <p>
            测试<br>				<!--p是div后代:使用div p,darkred-->
            <span>测试</span>		<!--span是div后代:使用div span,green-->
        </p>
        <span>测试</span>			<!--span是div后代:使用div span,green-->
    </div>
</body>
</html>

优先级

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>子代和后代的优先级</title>
    <style>
        p {
            color: red;
        }
        span {
            color: blue;
        }
        div p {
            font-weight: bold;
            color: darkred;
        }
        div span {
            font-weight: bold;
            color: green;
        }
        div > span {
            font-weight: bold;
            color: orange;
        }

        .c1 {               /* class选择器 */
            font-weight: bolder;
            color: purple;
            background-color: pink;
        }
        .c1 > p {           /* 子代选择器 */
            color: greenyellow;
            background-color: gray;
        }
        .c1 > span {
            color: orangered;
        }
    </style>
</head>
<body>
    <!--非后代-->
    <p>
        测试1<br>					<!--p非div后代:使用p,red-->
        <span>测试2</span>		<!--span非div后代:使用span,blue-->
    </p>
    <!--后代和直接子代-->
<hr>
    <div>
        测试3
        <p>
            测试4<br>				<!--p是div后代:使用div p,darkred-->
            <span>测试5</span>	<!--span是div后代:使用div span,green-->
        </p>
        <span>测试6</span>		<!--span是div直接子代:使用div > span,orange-->
    </div>
<hr>
    <div class="c1">
        测试7						<!--class属性使用class选择器c1,purple-->
        <p>
            测试8<br>				<!--p是div直接子代:使用.c1 > p,greenyellow-->
            <span>测试9</span>	<!--span是div后代:使用div p,green-->
        </p>
        <span>测试10</span>		<!--span是div直接子代:使用.c1 > span,orangered-->
    </div>
</body>
</html>

<!-- 子代会继承父代的样式属性,相同情况下,直接子代的样式优先于后代的样式 -->
<!-- 测试7:选择器c1的样式属性会覆盖div的样式属性 -->
<!-- 测试8:继承父代div的.c1的样式属性,使用.c1 > p的样式属性 -->
<!-- 测试9:继承父代.c1 > p的样式属性,使用div p的样式属性 -->
<!-- 测试10:继承父代div的.c1的样式属性,使用.c1 > p的样式属性-->

伪类选择器

/* 伪类选择器 */
/*
	伪类选择器可以为标签的不同状态分别设置样式,但必须与基础选择器结合使用才能生效。
	:hover		# 定义鼠标滑过时的状态
		cursor: pointer;	# 鼠标变为手指
	:active		# 定义鼠标点击时的状态
*/

标签名:hover {
	属性:;
}
.class名:hover {
	属性:;
}
#id名:hover {
	属性:;
}

标签名:active {
	属性:;
}
.class名:active {
	属性:;
}
#id名:active {
	属性:;
}
示例:滑过、点击
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>鼠标滑过、点击</title>
    <style>
        h1 {
            background-color: gray;
            color: white;
        }
        h1:hover {				/* :hover定义鼠标滑过时的状态 */
            background-color: lightpink;
            color: purple;
        }
        h2 {
        	background-color: gray;
        	color: yellowgreen;
        	display: inline;	/* inline行内元素,缺省block块级元素 */
        }
        h2:hover {
            background-color: lightpink;
            color: green;
            cursor: pointer;	/* 鼠标由箭头变为手指 */
        }
        h3 {
            background-color: gray;
            color: white;
        }
        h3:active {				/* :active定义鼠标点击时的状态 */
            background-color: lightpink;
            color: purple;
        }
    </style>
</head>
<body>
    <h1>测试</h1>
    <h2>测试</h2>
    <h3>测试</h3>
</body>
</html>
示例:过渡速度
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>过渡速度</title>
    <style>
        h1 {
            background-color: gray;
            color: white;
            transition: all 5s;			/* transition定义过渡,all所有属性,5s过渡的时间 */
        }
        h1:hover {
            background-color: lightpink;
            color: purple;
        }
        h2 {
          	background-color: gray;
        	color: yellowgreen;
        	display: inline;
        	transition: color 5s;		/* 只有color过渡时间5s,其它使用默认过渡时间 */
        }
        h2:hover {
            background-color: lightpink;
            color: green;
        }
    </style>
</head>
<body>
    <h1>测试</h1>
    <h2>测试</h2>
</body>
</html>

JavaScript

JS(JavaScript)

# JS与HTML
JS是一种浏览器解释型语言,嵌套在HTML文件中交给浏览器解释执行。主要用来实现网页的动态效果、用户交互以及前后端的数据传输等。

# JS注释语法
// 注释内容
/*
	注释内容
	注释内容
*/

# JS的组成
- 核心语法 ECMAScript 规范了JS的基本语法
- 浏览器对象模型 BOM(Browser Object Model),提供了一系列操作浏览器的方法
- 文档对象模型 DOM(Document Object Model),提供了一系列操作的文档的方法

HTML使用JS的方式

元素绑定事件

# 元素绑定时间
事件:指用户的行为(单击、双击等)或元素的状态(输入框的焦点状态等)
事件处理:元素监听某种事件并在事件发生后自动执行事件处理函数。
常用事件:onclick(单击事件)
...
<body>
    <!--实现点击按钮在F12控制台输出Hello World-->
    <button onclick="console.log('Hello World');">控制台</button>
    <br>
    <!--实现点击按钮在页面出现告警弹窗Hello World-->
    <button onclick="alert('Hello World');">弹窗</button>
</body>
...

文档内嵌、外部链接

# 文档内嵌
文档内嵌:在HTML文档中直接使用<script></script>内嵌JS代码。
script标签可以书写在文档的任意位置,书写多次。
	程序一旦加载到script标签就会立即执行其内部的JS代码,因此不同的位置会"影响"代码最终的执行效果。
	通常放在head中的js是为了发生点击等事件时调用,放在body中的js是为了生成一定的内容。
	一般会写在html标签之外。
	
# 文档内嵌的语法
<script>		# 缺省<script type="text/javascript">
	JS代码
</script>


# 外部链接
外部链接:在HTML文档中使用<script src=""></script>引入外部的.js文件。

# 外部链接的语法
<script src=".js文件路径"></script>

# 注意,script标签既可以用来实现文档内嵌,也可以用来实现外部链接,但不能同时实现两种方式。
]# cat js/j1.js
alert("js文件的弹窗")			// alert()告警弹窗
console.log("这是一个js文件");	// console.log()控制台输出

]# cat test.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JS使用方法</title>
    <!--文档内嵌-->
    <script>
        alert("head的弹窗");
    </script>
    <!--外部链接-->
    <script src="js/j1.js"></script>
</head>
<body>
    <script>
        alert("body的弹窗");
    </script>
    <script src="js/j1.js"></script>
</body>
    <script>
    alert("html中的弹窗");
    </script>
    <script src="js/j1.js"></script>
</html>
<script>
    alert("html外的弹窗");
</script>
<script src="js/j1.js"></script>

<!--
执行效果:
    head的弹窗			# 确定
    js文件的弹窗			# 确定。控制台:这是一个js文件
    body的弹窗			# 确定
    js文件的弹窗			# 确定。控制台:这是一个js文件
    html中的弹窗		# 确定
    js文件的弹窗			# 确定。控制台:这是一个js文件
    html外的弹窗		# 确定
    js文件的弹窗			# 确定。控制台:这是一个js文件
-->

JS基础语法

# JS基本语法
JS严格区分大小写。
JS是由语句组成,语句由关键字、变量、常量、运算符、方法组成。
分号可以作为语句结束的标志,也可以省略。

# 命名规范
+ 自定义变量名、常量名、函数名、方法名,可以由数字、字母、下划线、美元符$ 组成,禁止以数字开头。
+ 禁止命名为关键字(var const function if else for while do break case switch return class)。
+ 变量名严格区分大小写。
+ 尽量见名知意,变量名多个单词组成采用小驼峰,例如:"userName"

变量的声明

# 变量

# 变量的声明和赋值
var a;					# 声明变量
a = 10;					# 给现有变量赋值
var b = 22;				# 声明变量并赋值
var x,y,z;				# 声明多个变量
var m = 10, n = 22;		# 声明多个变量并赋值

# 注意事项:
+ 声明变量但未赋值,变量初始值为undefined。
+ 声明变量不赋值不能省略var。
+ 声明变量并赋值不建议省略var,某些浏览器可能会报错。

数据类型

基本数据类型
<script>
    
    // number 数值类型
    var n1 = 10;
    console.log(n1, typeof n1)				// 10 'number'
    var n2 = 3.14;
    console.log(n2, typeof n2)				// 3.14 'number'

    // string 字符串类型
    var s1 = "10";
    var s2 = "张三";
    console.log(s1, typeof s1);				// 10 string

    // boolean 布尔类型
    var b1 = true;
    var b2 = false;
    console.log(b1, typeof b1);				// true 'boolean'

    // undefined 声明变量且未赋值时的初始值
    var u;
    console.log(u, typeof u);				// undefined 'undefined'

    // 空对象,需主动赋值null
    var n1 = null;
    console.log(n1, typeof n1);				// null 'object'
    var n3 = null;
    console.log(n3, typeof n3);				// null 'object'

    // 数组对象
    var arr = [1, 3.14, "a", true, false]
    console.log(arr, typeof arr);			// (5) [1, 3.14, 'a', true, false] 'object'
    console.log(arr[0], typeof arr[0]);		// 1 'number'
    console.log(arr[4], typeof arr[4]);		// false 'boolean'
    console.log(arr[-1], typeof arr[-1]);	// undefined 'undefined'。注意没有逆向索引

    // 字典对象
    var dic = {one: 1, two: "zhangsan"};
    console.log(dic, typeof dic);				// {one: 1, two: 'zhangsan'} 'object'
    console.log(dic.one, typeof dic["one"]);	// 1 'number'
    console.log(dic["two"], typeof dic.two);	// zhangsan string

</script>
字符串类型、数组对象、字典对象
<script>
    // 字典对象添加键值对
    var person = {name: "张三", gender: "male"};
    person.age = 19;
    person.hobby = "唱歌";
    console.log(person);

    // 字符串常用操作
	var info = "Hello world";
	console.log(info[0]);				// H。注意没有逆向索引
	console.log(info.length);			// 11
	console.log(info.slice(0,6));		// Hello
	console.log(info.search("world"));	// 6。返回起始位索引
	console.log(info.search("forld"));	// -1。没有找到返回-1
	console.log(123 + "," + info);		// 123,Hello world

    // 字符串格式化
    var name = "Tom";
    console.log(`I'm ${name}`);			// I'm Tom

    // 数组的常用方法
    var arr = [1,2,3,4,5,6,7];
    console.log(arr.length);  			// 7
    console.log(arr.slice(1,3));  		// (2) [2, 3]
    arr.push(10); 
    console.log(arr);				// (8) [1, 2, 3, 4, 5, 6, 7, 10]
    arr.pop();
    console.log(arr);				// (7) [1, 2, 3, 4, 5, 6, 7]

</script>
数据类型转换
<script>
// 强制类型转换  
    // 转换为字符串类型
    var n1 = 10;
    console.log(n1, typeof n1);				// 10 'number'
    n1 = n1.toString();
    console.log(n1, typeof n1);				// 10 string

    var b1 = true;
    console.log(b1, typeof b1);				// true 'boolean'
    b1 = b1.toString();
    console.log(b1, typeof b1);				// true string

    // 转换为数值类型。成功返回数值,失败返回NaN(not a number)
    var s1 = "22";
    console.log(s1, typeof s1);				// 22 string
    s1 = Number(s1);
    console.log(s1, typeof s1);				// 22 'number'

    var s2 = "5a";
    console.log(s2, typeof s2);				// 5a string
    s2 = Number(s2);
    console.log(s2, typeof s2);				// NaN 'number'

</script>

<script>
// 隐式类型转换/自动转换
// 非字符串类型的数据与字符串拼接后,结果为字符串类型
    var n = 33;
    var s = "abc";
    res = n + s;
    console.log(n, typeof n);				// 33 'number'
    console.log(res, typeof res);			// 33abc string
</script>    

运算符

赋值运算符:=
算术运算符:+    -    *    /    %  
复合运算符:+=   -=   *=   /=   %=
自运算:++      --
比较运算符(结果为布尔值):>  <  >=  <=  ==(相等)  !=(不相等)  ===(全等)  !==(不全等)
    相等 : 不考虑数据类型,只做值的比较(包含自动类型转换)
    全等 : 不会进行数据类型转换,要求数据类型一致并且值相等才判断全等
逻辑运算符:&&   ||   !
<script>
    // 自运算,前缀和后缀的区别
    var a = 10;
    console.log(a++); 	// 10。先使用现值,再自增
    console.log(a); 	// 11
    console.log(++a); 	// 12。先自增,再使用自增后的值
    console.log(a); 	// 12

    // 相等。带有隐式的转换
    console.log("100" == 100);  	// true
    // 全等。判断类型和数值,类似python ==
    console.log("100" === 100);  	// false

    // 逻辑运算符
    console.log(true && false);  	// false
    console.log(true || false); 	//true
    console.log(!true);				// false

    // 特殊的
    var age = 50
    console.log(18<=age<=60)		// true。18<=age为true,true(1)<=60为true
    console.log(70>=age>=10)		// false。70>=age为true,true (1) >=10为false
</script>

分支与循环

if 分支

// if语句
if(条件表达式){
    条件成立时执行;
}

if (条件表达式) {
    条件成立时执行
}else{
    条件不成立时选择执行;
}

if(条件1){
    条件1成立时执行;
}else if(条件2){
    条件2成立时执行;
}else if(条件3){
    条件3成立时执行;
}...else{
    条件不成立时执行;
}

// 以下条件为false
if(0){}
if(0.0){}
if(""){} 			//空字符串
if(undefined){}
if(NaN){}
if(null){}
<script>
    var score = prompt("输入一个分数:")
    if(score >= 90){
        console.log("优秀");
    }else if(score >= 80){
        console.log("良好");
    }else if(score >= 60){
        console.log("及格");
    }else{
        console.log("不及格");
    }
</script>

while循环

// 第一种,先判断
var 循环变量 = 初始值;
while(条件表达式){
   循环体;
   更新循环变量;
}

// 第二种,后判断,至少执行一次
var 循环变量 = 初始值;
do{
    循环体;
    更新循环变量;
}while(条件表达式);
<script>
    // while 先判断
    var n = 0;
    while(n < 4){
        console.log(n);
        n++;
    }
    // while 后判断,至少执行一次
    var m = 0;
    do{
        console.log(m);
        m++;
    }while(m < 4);
</script>

for 循环

for (var 循环变量 = 初始值; 条件表达式; 更新循环变量){
    循环体;
}
// 特殊的,数组对象
var 数组对象 = [元素1,元素2,元素n]
for(var i in 数组对象){
    循环体
}
<script>
	// for
    for(var i = 0; i < 4; i++){
        console.log(i);
    }
    // for 数组对象
    var arr = [1, 3.14, "a", true, false]
    for(var i in arr){
        console.log(i, arr[i], typeof arr[i])
    }
    /*
        0 1 number
        1 3.14 number
        2 a string
        3 true boolean
        4 false boolean
    */
</script>

循环关键字

# 循环关键字
break		# 结束所在循环
continue  	# 结束当次循环,开始下一次循环

函数、匿名函数

// 函数声明
function 函数名(参数列表){
    函数体;
    return 返回值;			// 注意:函数中执行return语句后会退出函数
}

// 函数调用
函数名(参数列表);

// 匿名函数:省略函数名的函数
// 使用方式一
(function (形参)){
 	函数体
})(实参);
// 使用方式二:定义变量接收匿名函数
var fn = function(形参){函数体};
fn();
<script>
    var a = prompt("请输入一个数");     // 3.14,string
    a = Number(a);
    
    // 普通函数
    function add_num(a, b){
    	return a + b;
    }
    console.log(add_num(a, 22));      // 25.14

    // 匿名函数的使用方式一
    var sum;
    sum = (function (a,b){return a + b})(a, 22)
    console.log(sum)				// 25.14
    
	// 匿名函数使用方式二
    var fn = function (a,b){return a + b}
    console.log(fn(a,22))			// 25.14
</script>

DOM

# DOM和BOM
DOM(Document Object Model,文档对象模型),提供操作HTML文档的一套工具。
BOM(Browser Object Model,浏览器对象模型),提供操作浏览器的一套工具。

JS不能直接操作HTML标签,可以通过操作DOM对象来操作HTML的元素。

# 几个概念
document	# 代表整个页面
element		# 代表HTML文档中的一个个元素
node		# 节点,HTML文档中所有内容(元素、属性、文本)都可以被封装,称之为节点
			# 创建节点对象后,通过方法操作对象的相关属性来操作节点。

创建DOM

# 创建元素节点对象(用于操作标签)
document.getElementById("id名")				# 通过属性id来查找元素,得到一个DOM对象
document.getElementsByTagName("元素名")	   # 通过元素名来查找元素,得到DOM对象的集合
document.getElementsByName("name名")			# 通过属性name来查找元素,得到DOM对象的集合
document.getElementsByClassName("class名")	 # 通过属性class来查找元素,得到DOM对象的集合

# document方法的区别
1. getElementById() 得到一个DOM对象。
2. getElementsByName()、getElementsByTagName()、getElementsByClassName() 得到DOM对象的集合,集合中每个元素都是一个DOM对象,顺序是其在HTML文档中出现的顺序,用法同数组。

# 属性id、class、name和元素名的区别
1. 每个id只能给一个元素独享,每个class可以给多个元素共享。
2. 属性name一般用于单选框和多选框。
3. 通过元素名查找会作用于HTML文档中该元素。

请添加图片描述

<!DOCTYPE html>
<html lang="zh_CN">
<head>
    <meta charset="UTF-8">
    <title>创建DOM</title>
</head>
<body>
    <p>兴趣爱好:</p>
    <div>
        <input type="checkbox" name="hobby" class="c1" value="a"/>爬山<br>
        <input type="checkbox" name="hobby" class="c1" value="b"/>游泳<br>
        <input type="checkbox" name="hobby" value="c"/>远足<br>
        <input type="checkbox" name="hobby" id="i1" value="c"/>唱歌<br>
    </div>
    <button onclick="checkNo();">全不选</button>
    <button onclick="checkReverse();">反选</button>
    <button onclick="checkHeadTwo();">选前两个</button>
    <button onclick="checkTailOne();">选最后一个</button>
</body>
</html>
<script type="text/javascript">
    // 全不选
    function checkNo(){
        // document.getElementsByTagName() 通过元素名查找元素,返回多个元素节点对象的集合
        var hobbys = document.getElementsByTagName("input");
        for (var i in hobbys) {
            hobbys[i].checked = false;
        }

    }
    //反选
    function checkReverse(){
        // document.getElementsByName() 通过属性name查找元素,返回多个元素节点对象的集合
        var hobbys = document.getElementsByName("hobby");
        for (var i = 0; i < hobbys.length; i++) {
            hobbys[i].checked = !hobbys[i].checked;
        }
    }
    // 选前两个
    function checkHeadTwo(){
        // document.getElementsByClassName() 通过属性class查找元素,返回多个元素节点对象的集合
        checkNo();
        var hobbys = document.getElementsByClassName("c1");
        for (var i = 0; i < hobbys.length; i++) {
            hobbys[i].checked = true;
        }
    }
    // 选最后一个
    function checkTailOne(){
        // document.getElementById() 通过属性id查找元素,返回一个标签对象
        checkNo()
        var t = document.getElementById("i1");
        t.checked = true;
    }
</script>

DOM的属性和方法

# 元素节点对象的属性和方法
DOM.innerHTML				# 获取DOM起始标签和结束标签之间的内容(包含标签)
DOM.innerText				# 获取DOM起始标签和结束标签之间的文本(不包含标签)

DOM.属性名				  	  # 获取DOM的属性的属性值
DOM.属性名 = "属性值"			# 设置DOM的属性的属性值。只对所在function有效
	# 特殊的,属性style的写法
    DOM.style = "width: 300px;";	# 写法一
    DOM.style.width = "300px";		# 写法二
	# 注意:
        1. 属性值为字符串形式,单位不能省略。
        2. 如果css属性名包含连接符,使用js访问时,改为小驼峰:font-size ——》fontSize
        
DOM.getAttribute("属性名");			# 查看DOM的属性
DOM.setAttribute("属性名", "属性值") 	   # 设置DOM的属性。对其它function有效
DOM.removeAttribute("属性名")			# 删除DOM的属性。对其它function有效

DOM.childNodes				# 获取DOM的子节点,返回DOM对象的集合
DOM.parentNode				# 获取DOM的父节点,返回一个DOM对象
DOM.previousSibling			# 获取DOM的前一个兄弟节点,返回一个DOM对象

# 按钮
# 按钮的用法一
<html> <button onclick="函数名();">按钮内容</button> </html>
<script> function 函数名(){代码} </script>
# 按钮的用法二
<html> <button id="id名">按钮内容</button> </html>
<script> document.getElementById("id名").onclick = function(){代码块} </script>

DOM.innerHTMLDOM.innerTextDOM.style.子属性

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>DOM的属性和方法</title>
    <style>
        div {
            width: 100px;
            height: 100px;
            background-color: red;
            transition: all 0.3s;
        }
    </style>
</head>
<body>
    <p class="c">使用<span style="font-weight:bold;">变大</span>按钮,方块变大</p>
    <p>
        <button id="btnHtml">innerHTML</button>
        <button id="btnText">innerText</button>
    </p>
    <button onclick="bigger()">变大</button>
    <div id="box"></div>
</body>
</html>
<script>
    // 按钮的用法一
    document.getElementById("btnHtml").onclick = function (){
        // DOM.innerHTML 获取标签之间的内容(包含标签)
        alert(document.getElementsByTagName("p")[0].innerHTML);    // 使用<span style="font-weight:bold;">变大</span>按钮,方块变大
    }
    document.getElementById("btnText").onclick = function (){
        // DOM.innerText 获取标签之间的文本(不包含标签)
        alert(document.getElementsByClassName("c")[0].innerText);  // 使用变大按钮,方块变大
    }
    // 按钮的用法二
    function bigger() {
        var a = document.getElementById('box')
        // 写法一:DOM.style = "子属性:值;"
        // 写法二:DOM.style.子属性 = "值"
        // 属性名包含连接符时,使用小驼峰
        alert(a.style.backgroundColor);         // 空
        a.style = "width: 200px;";
        a.style.height = "200px";
        a.style.backgroundColor = "green";
        alert(a.style.backgroundColor);         // green
        // function执行结束后,方块变大变绿
    }
</script>

DOM.childNodesDOM.parentNodeDOM.previousSibling

<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>DOM的属性和方法</title>
</head>
<body>
<div id="question">
  <p>你喜欢哪个城市?</p>
  <ul id="city">
     <li id="bj">北京</li><li>上海</li>
     <li>东京</li><li>首尔</li></ul>
  <p>你手机的操作系统是?</p>
  <ul id="phone"><li>IOS</li><li id="android"><span style="color:red;">Android</span></li><li>Windows Phone</li></ul>
</div>
<div id="btnList">
   <div>01<button id="btn01">统计城市有几个选项</button></div>
   <div>02<button id="btn02">查询id为city的节点的子节点个数</button></div>
   <div>03<button id="btn03">查询id为phone的节点的子节点个数</button></div>
   <div>04<button id="btn04">查询id为phone的节点的所有子节点标签之间的内容</button></div>
   <div>05<button id="btn05">查询id为phone的节点的所有子节点标签之间的文本</button></div>

   <div>11<button id="btn11">查询id为android的节点的父节点</button></div>
   <div>12<button id="btn12">查询id为android的节点的前一个兄弟节点</button></div>
</div>
</body>
</html>
<script type="text/javascript">
   var city = document.getElementById("city");
   var cityChilds = city.childNodes;
   var phone = document.getElementById("phone");
   var phoneChilds = phone.childNodes;

   document.getElementById("btn01").onclick = function(){
      var lis = city.getElementsByTagName("li");    // id为city的元素下的li元素
      alert(lis.length);              // 4
   };
   // 空字符也算字符串,因此是字符串节点
   document.getElementById("btn02").onclick = function(){
      alert(cityChilds.length);      // 6
      console.log(cityChilds);       // NodeList(6) [text, li#bj, li, text, li, li]
   };
   document.getElementById("btn03").onclick = function(){
      alert(phoneChilds.length);     // 3
      console.log(phoneChilds);      // NodeList(3) [li, li#android, li]
   };
   document.getElementById("btn04").onclick = function(){
      alert(phone.firstChild.innerHTML);    // IOS
      alert(phoneChilds[1].innerHTML);      // <span style="color:red;">Android</span>
      alert(phone.lastChild.innerHTML);     // Windows Phone
   };
   document.getElementById("btn05").onclick = function(){
      alert(phone.firstChild.innerText);    // IOS
      alert(phoneChilds[1].innerText);      // Android
      alert(phone.lastChild.innerText);     // Windows Phone
   };

   var android = document.getElementById("android");
   document.getElementById("btn11").onclick = function(){
      var parentNode = android.parentNode;            // parentNode父节点
      console.log(parentNode)             // <ul id="phone">xxx</ul>
      alert(parentNode.innerHTML);        // <li>IOS</li><li id="android">Android</li><li>Windows Phone</li>
      alert(parentNode.innerText);        /*
                                             IOS
                                             AnDroid
                                             Windows Phone
                                          */
   };
   document.getElementById("btn12").onclick = function(){
      var previousSibling = android.previousSibling;  // previousSibling前一个兄弟节点
      alert(previousSibling.innerHTML);   // IOS
   };
</script>

DOM.xxxAttribute()DOM.属性

<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>DOM的属性和方法</title>
</head>
<body>
<div>
  name:&nbsp;
  <input type="text" name="name" id="username" placeholder="你的名字" maxlength="3"/>
</div>
<div id="btnList">
   <div><button id="get">查询</button></div>
   <div><button id="func">属性和方法</button></div>
</div>
</body>
</html>
<script type="text/javascript">
    document.getElementById("get").onclick = function(){
        var username = document.getElementById("username");
        alert(username.placeholder);
        alert(username.name)
        console.log(username);
    };
    document.getElementById("func").onclick = function(){
        var username = document.getElementById("username");
        username.placehoder = "名字";           // 只在本function中有效,不影响元素本身
        username.setAttribute("name", "user"); // 被加载后对其它function也生效,影响元素本身
        username.removeAttribute("maxlength"); // 被加载后对其它function也生效,影响元素本身
        alert(username.placehoder);
        alert(username.name);
        console.log(username);
    };
</script>

<!--
按钮get:
    弹窗:你的名字     name
    控制台:<input type="text" name="name" id="username" placeholder="你的名字" maxlength="3"/>
    文本框底纹:你的名字
按钮func:
    弹窗:名字     user
    控制台:<input type="text" name="user" id="username" placeholder="你的名字"/>
    文本框底纹:你的名字
按钮get:
    弹窗:你的名字     user
    控制台:<input type="text" name="user" id="username" placeholder="你的名字"/>
    文本框底纹:你的名字
-->

end

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值