...
HTML 的 lang 属性可用于网页或部分网页的语言。这对搜索引擎和浏览器是有帮助的;根据 W3C 推荐标准,您应该通过 标签中的 lang 属性对每张页面中的主要语言进行声明即lang=""
...
6、属性选择器:对带有指定属性的所有元素设置样式:
1》单纯属性选择器:
[title]{
color:red;
}
2》属性和值选择器:
[title=W3School]{
border:5px solid blue;
}
3》属性和值选择器-多个值:
~=:
[title~=hello]{//所有title属性并且属性值以空格分割的且某个空格间内容含hello的
color:red;
}
Hello world
W3School Hello students!
|=:
[title|=mama]{//所有title属性并且属性值以mama开头的,且mama为单独的词组
color:red;
}
4》元素+属性
input[type="text"]
{
width:150px;
display:block;
margin-bottom:10px;
background-color:yellow;
font-family: Verdana, Arial;
}
5》元素+属性
[attribute]选取带有指定属性的元素
[attribute=value]用于选取带有指定属性和值的元素
[attribute~=value]用于选取属性值中包含指定词汇的元素,且此词汇为单独的,且由空格链接
[attribute|=value]用于选取带有以指定值开头的属性值的元素,该值必须是单独的,且由-链接
[attribute^=value]匹配属性值以指定值开头的每个元素
[attribute$=value]匹配属性值以指定值结尾的每个元素
[attribute*=value]匹配属性值中包含指定值的每个元素
7.29
7、创建css
1》外部样式:
2》内部样式:
hr {color: sienna;}
p {margin-left: 20px;}
body {background-image: url("images/back40.gif");}
3》内联样式:
This is a paragraph
8、背景:
1》backgoround-color:transparent(透明);#00ff00;rgb(250,0,255);yellow
p {background-color: gray; padding: 20px;}
2》background-image:
body {background-image: url(/i/eg_bg_04.gif);}
3》背景重复:background-repeat: no-repeat; repeat-x; repeat-y;repeat
body
{
background-image: url(/i/eg_bg_03.gif);
background-repeat: repeat-y;
}
4》背景定位:background-position:
4.1》background-position+关键字:top、bottom、left、right、center;默认值left top 位置关键字可以按任何顺序出现,只要保证不超过两个关键字 - 一个对应水平方向,另一个对应垂直方向;如果只出现一个关键字,则认为另一个关键字是 center;
body
{
background-image:url('/i/eg_bg_03.gif');padding: 20px;
background-repeat:no-repeat;
background-position:center;
}
等价位置关键字:
center = center center
top = top center 或 center top
bottom = bottom center 或 center bottom
right = right center 或 center right
left = left center 或 center left
4.2》background-position+百分数值:
background-position:100% 100% //右下角
background-position:0% 0% //左下角
如果只提供一个百分数值,所提供的这个值将用作水平值,垂直值将假设为 50%。这一点与关键字类似。
4.3》background-position+长度值:
background-position:50px 100px;
5》背景关联:backgorund-attachment 默认值:scroll
如果文档比较长,那么当文档向下滚动时,背景图像也会随之滚动。当文档滚动到超过图像的位置时,图像就会消失。
background-attachment:fixed
6》将所有背景属性简写到一个声明中:
body
{
background: #ff0000 url(refresh1.png) no-repeat fixed center;
}
9、css文本:
0》文本颜色 color:
1》缩进文本:text-indent
text-indent:(使用具体值)
一般来说,可以为所有块级元素应用 text-indent,但无法将该属性应用于行内元素,图像之类的替换元素上也无法应用 text-indent 属性。不过,如果一个块级元素(比如段落)的首行中有一个图像,它会随该行的其余文本移动
如果想把一个行内元素的第一行“缩进”,可以用左内边距或外边距创造这种效果。
text-indent:(使用百分比值)缩进值是父元素宽度的百分比
text-indent:(cm)p {text-indent: 1cm}
div {width: 500px;}
p {text-indent: 20%;}
缩进值是父元素的 20%,即 100 个像素
text-indent:(继承)可以继承给内层元素
div#outer {width: 500px;}
div#inner {text-indent: 10%;}
p {width: 200px;}
some text. some text. some text.
this is a paragragh. //继承父元素div的inner样式
2》对齐:text-align left;right;center;justify(两端对齐)
3》字间隔:word-spacing :默认normal(0)
p.spread {word-spacing: 30px;}
p.tight {word-spacing: -0.5em;}
4》字母间隔:letter-spacing:
h1 {letter-spacing: -0.5em}
h4 {letter-spacing: 20px}
5》字符转换:text-transform: none;uppercase;lowercase;capitalize(对每个单词的首字母大写)
6》文本装饰:text-decoration:none;underline;overline;line-through;blink(文本闪烁,但实际测试无效果)
结合:a:link a:visited {text-decoration: underline overline;}
7》处理空白符:white-sapce
normal:丢掉多余的空白符;换行字符(回车)会转换为空格;一行中多个空格的序列也会转换为一个空格
pre:空白符不会被忽略;注:E 7 以及更早版本的浏览器不支持该值,因此请使用非 IE 的浏览器来查看上面的实例
nowrap:防止元素中文本换行,除非使用br元素;
pre-wrap:元素中的文本会保留空白符序列,但是文本行会正常地换行;
pre-line:元素中的文本会不保留空白符序列,但是文本行会正常地换行;
pre-line |
合并 |
保留 |
允许 |
normal |
合并 |
忽略 |
允许 |
nowrap |
合并 |
忽略 |
不允许 |
pre |
保留 |
保留 |
不允许 |
pre-wrap |
保留 |
保留 |
允许 |
8》的文本方向:
块级元素:direction:ltr(默认);rtr;inherit
行内元素:unicode-bidi :
9》行间距:
百分比:在大多数浏览器中默认行高大约是 110% 到 120%。
p.small {line-height: 100%}
p.big {line-height: 200%}
Px:在大多数浏览器中默认行高大约是 20px
p.small {line-height: 10px}
p.big {line-height: 20px}
数字:默认行高大约是 1
p.small {line-height: 0.5}
p.big {line-height: 2}
10、CSS字体:通用字体 + 特定字体
1》font-family字体系列:
使用通用字体(有相似外观的字体系统组合):sans-serif;serif;monospace; cursive; fantasy
特定字体(具体的字体系列):Times;Courier。。。。
用户代理上没有安装 Georgia(特定) 字体,就只能使用用户代理的默认字体来显示 h1 元素。可以通过结合特定字体名和通用字体系列来解决这个问题如下:
h1 {font-family: Georgia, serif;}
也可以为给定的元素指定一系列类似的字体。要做到这一点,需要把这些字体按照优先顺序排列,然后用逗号进行连接:p {font-family: Times, TimesNR, 'New Century Schoolbook',
Georgia, 'New York', serif;}
当字体名中有一个或多个空格(比如 New York),或者如果字体名包括 # 或 $ 之类的符号,才需要在 font-family 声明中加引号,单引号或双引号都可以接受。但是,如果把一个 font-family 属性放在 HTML 的 style 属性中,则需要使用该属性本身未使用的那种引号:
...
2》font-style字体风格:normal;italic(斜体);oblique(倾斜)
斜体(italic)是一种简单的字体风格,对每个字母的结构有一些小改动,来反映变化的外观。与此不同,倾斜(oblique)文本则是正常竖直文本的一个倾斜版本;通常情况下,italic 和 oblique 文本在 web 浏览器中看上去完全一样。
3》font-variant字体形变:设定小型大写字母(小型大写字母的字体显示文本,这意味着所有的小写字母均会被转换为大写,但是所有使用小型大写字体的字母与其余文本相比,其字体尺寸更小)
取值:small-caps(小型大写字母);normal
4》font-weight字体加粗:取值范围:100 ~ 900 ;400(normal);700(bold);lightter;bold;bolder;
5》font-size字体大小:
绝对值(px为单位):将文本设置为指定的大小;不允许用户在所有浏览器中改变文本大小(不利于可用性);绝对大小在确定了输出的物理尺寸时很有用
h1 {font-size:60px;}
相对大小(相对于父元素)(em为单位):相对于周围的元素(一般是相对于父元素)来设置大小;允许用户在浏览器改变文本大小;
1em 等于当前的字体尺寸。如果一个元素的 font-size 为 16 像素,那么对于该元素,1em 就等于 16 像素。在设置字体大小时,em 的值会相对于父元素的字体大小改变;
p {font-size:0.875em;}
(注:16 等于父元素的默认字体大小,假设父元素的 font-size 为 20px,那么公式需改为:pixels/20=em)
h1 {font-size:3.75em;} /* 60px/16=3.75em */
h2 {font-size:2.5em;} /* 40px/16=2.5em */
p {font-size:0.875em;} /* 14px/16=0.875em */
注意:如果没有规定字体大小,普通文本(比如段落)的默认大小是 16 像素 (16px=1em)。
在上面的例子中,以 em 为单位的文本大小与前一个例子中以像素计的文本是相同的。不过,如果使用 em 单位,则可以在所有浏览器中调整文本大小。
不幸的是,在 IE 中仍存在问题。在重设文本大小时,会比正常的尺寸更大或更小。
结合使用百分比和 EM
在所有浏览器中均有效的方案是为 body 元素(父元素)以百分比设置默认的 font-size 值:body {font-size:100%;}
6》简写属性:font 用简写属性将字体属性设置在一个声明内
p.ex2
{
font:italic bold 12px/30px arial,sans-serif;(逗号前的顺序好像不能任意互换,有时候换位后则不显示目标效果;只有italic 和 bold可互换,其属性不能互换,否则无目标效果)
background-color:red;
}
11、CSS链接:能够设置链接样式的 CSS 属性有很多种(例如 color, font-family, background 等等);链接的特殊性在于能够根据它们所处的状态来设置它们的样式
链接四种状态:
a:link 普通、未被访问的链接
a:visited 已经被访问的链接
a:hover 鼠标指针位于链接上方
a:active 链接被点击的时刻
注意:当为链接的不同状态设置样式时,请按照以下次序:
- a:hover 必须位于 a:link 和 a:visited 之后
- a:active 必须位于 a:hover 之后
即 l v h a (link visited hover active)
例:
a:link,a:visited
{
display:block;
font-weight:bold;
font-size:14px;
font-family:Verdana, Arial, Helvetica, sans-serif;
color:#FFFFFF;
background-color:#98bf21;
width:120px;
text-align:center;
padding:4px;
text-decoration:none;
}
a:hover,a:active
{
background-color:#7A991A;
}
12、CSS列表:
1》列表类型:list-style-type(与学习html中type属性相似);(列表点样式)
无序:disc ; circle ;square ;none
有序:upper-roman ;lower-roman ;upper-alpha ;lower-alpha;decimal
「HTML列表的type属性
【无序列表属性:type="disc”(圆黑点,默认) “circle”(圆圈) “square”(正方形)】
【有序列表属性:type=“A”; “a”(默认);”I”(罗马数字,大写i);”i”(小写罗马数字,小写i);decimal(阿拉伯数字)】
」
list-style-type:square;
所有的list-style-type类型如下:
ul.none {list-style-type: none}
ul.disc {list-style-type: disc}
ul.circle {list-style-type: circle}
ul.square {list-style-type: square}
ul.decimal {list-style-type: decimal}//1.
ul.decimal-leading-zero {list-style-type: decimal-leading-zero}//01.
ul.lower-roman {list-style-type: lower-roman}//i.
ul.upper-roman {list-style-type: upper-roman}//I.
ul.lower-alpha {list-style-type: lower-alpha}//a.
ul.upper-alpha {list-style-type: upper-alpha}//A.
ul.lower-greek {list-style-type: lower-greek}// α.
ul.lower-latin {list-style-type: lower-latin}// a.
ul.upper-latin {list-style-type: upper-latin}//A.
ul.hebrew {list-style-type: hebrew} //א.
ul.armenian {list-style-type: armenian}//
ul.georgian {list-style-type: georgian}//
ul.cjk-ideographic {list-style-type: cjk-ideographic}//一、
ul.hiragana {list-style-type: hiragana} //あ、
ul.katakana {list-style-type: katakana}//ア 、
ul.hiragana-iroha {list-style-type: hiragana-iroha}//い、
ul.katakana-iroha {list-style-type: katakana-iroha}//イ、
2》列表项图像:list-style-image (列表点样式)
list-style-image:url("/i/arrow.gif");
3》列表标志位置:list-style-position 规定列表中列表项目标记的位置:inside outside (列表点位置)
list-style-position:inside;
4》简写列表样式:list-style
list-style: inside url('/i/eg_arrow.gif');
list-style 的值可以按任何顺序列出,而且这些值都可以忽略。只要提供了一个值,其它的就会填入其默认值。
13、CSS表格:
1》表格边框:border
table,th,td{
border:1px solid blue;
}
2》折叠边框:border-collapse 设置是否将表格边框折叠为单一边框
border-collapse属性与borde合用:(如果没有规定 !DOCTYPE,border-collapse 属性可能会引起意想不到的错误)
取值:collapse(合并);separate(默认;不合并);
table
{
border-collapse:collapse;
}
table,th,td
{
border: 1px solid black;
}
3》表格宽度和高度:
width: px ;百分比(占父元素的)
height:px;百分比(占父元素的)
4》表格文本对齐:
text-align:水平对齐(左对齐left;右对齐right;居中center)
vertical-align:竖直对齐(底bottom;顶top;居中center)
5》表格内边距:padding:15px
6》单元格边距:border-spacing:xspaceing yspacing border-spacing: 40px 20px
7》caption-side:表格标题的位置 bottom;top
8》empty-cells:是否隐藏空单元格 取值:hide(隐藏);show(不隐藏,默认)
9》table-layout:设置显示单元、行和列的算法
取值:atomatic:根据td内的内容显示单元格宽度;与设定的width无关(默认。列宽度由单元格内容设定。)
Fixed:根据设定的width显示单元格宽度;与td内容无关(列宽由表格宽度和列宽度设定。)
14、CSS轮廓:outline 元素周围的一条线,border外围
outline-color:
outline-style:
outline-width:
outline: red 1px solid;
15、CSS模型概述:
16、css内边距:padding
在 CSS 中,width 和 height 指的是内容区域的宽度和高度。增加内边距、边框和外边距不会影响内容区域的尺寸,但是会增加元素框的总尺寸。
padding属性:长度px;百分比%;不能为负。padding-top;padding-right;padding-bottom;padding-left;
注意:上下内边距与左右内边距一致;即上下内边距的百分数会相对于父元素宽度设置,而不是相对于高度。
td.test2 {padding: 0.5cm 2.5cm} 上下是0.5cm;左右是2.5cm
17、css边框:border
1》边框与背景:元素的背景是内容、内边距和边框区的背景(边框在元素的背景上)
边框样式:样式是边框最重要的一个方面,这不是因为样式控制着边框的显示(当然,样式确实控制着边框的显示),而是因为如果没有样式,将根本没有边框。
2》边框样式:
多边样式:border-style
dotted;dashed;solid;double;groove;ridge;inset;outset
多种样式可以混合:p.aside {border-style: solid dotted dashed double;}
单边样式:border-top-style;border-right-style;border-bottom-style;border-left-style
p {border-style: solid solid solid none;}等价于p {border-style: solid; border-left-style: none;}
3》边框宽:border-width
px或em或三个关键字(thin、medium(默认)、thick)
p {border-style: solid; border-width: 5px;}
p {border-style: solid; border-width: thick;}
p {border-style: solid; border-width: 15px 5px 15px 5px;}
p {border-style: solid; border-width: 15px 5px;}
定义单边宽度:(上右下左)
border-top-width;border-right-width;border-bottom-width;border-left-border
4》无边框:border-style默认是none
p {border-style: none; border-width: 50px;}
5》边框颜色:border-color
p {
border-style: solid;
border-color: blue rgb(25%,35%,45%) #909090 red;
}
p {//上下蓝色;左右红色
border-style: solid;
border-color: blue red;
}
5.1、默认的边框颜色是元素本身的前景色。如果没有为边框声明颜色,它将与元素的文本颜色相同
5.2、如果元素没有任何文本,假设它是一个表格,其中只包含图像,那么该表的边框颜色就是其父元素的文本颜色(因为 color 可以继承)。这个父元素很可能是 body、div 或另一个 table。
单边颜色:border-top-color;border-right-color;border-bottom-color;border-left-color;
透明边框:transparent
从某种意义上说,利用 transparent,使用边框就像是额外的内边距一样;此外还有一个好处,就是能在你需要的时候使其可见。这种透明边框相当于内边距,因为元素的背景会延伸到边框区域(如果有可见背景的话)
6》练习
6.1》边框样式简写:
p {
border: medium double rgb(0,0,0)
}
6.2》设置某一边的简写:
p {
border-style:solid;
border-bottom:thick dotted #ff0000;
}
18、css外边距
1》margin (默认0)
auto
单位:可接受任何单位:px;in;cm;mm;em;%(百分数是相对于父元素的 width 计算)等
值复制:
CSS 定义了一些规则,允许为外边距指定少于 4 个值。规则如下:
- 如果缺少左外边距的值,则使用右外边距的值。
- 如果缺少下外边距的值,则使用上外边距的值。
- 如果缺少右外边距的值,则使用上外边距的值
2》单边外边距
margin-left;margin-right;margin-bottom;mragin-top
3》简写:p.margin {margin: 2cm 4cm 3cm 4cm}
19、css外边距合并
1》当一个元素出现在另一个元素上面时,第一个元素的下外边距与第二个元素的上外边距会发生合并。
展示结果为:这两个元素之中上边的元素的下边距不变,下边元素的上边距消失
2》当一个元素包含在另一个元素中时(假设没有内边距或边框把外边距分隔开),它们的上和/或下外边距也会发生合并。
展示结果为:里边的元素的上和/或下外边距消失,左右的不变
3》外边距甚至可以与自身发生合并。
假设有一个空元素,它有外边距,但是没有边框或填充。在这种情况下,上外边距与下外边距就碰到了一起,它们会发生合并;如果这个外边距遇到另一个元素的外边距,它还会发生合并
展示结果为:内侧元素不展示
20、css定位 定位概述
1》定位机制:普通流;浮动;绝对定位
除非专门指定,否则所有框都在普通流中定位。也就是说,普通流中的元素的位置由元素在 (X)HTML 中的位置决定。
块级框从上到下一个接一个地排列,框之间的垂直距离是由框的垂直外边距计算出来。
行内框在一行中水平布置。可以使用水平内边距、边框和外边距调整它们的间距。但是,垂直内边距、边框和外边距不影响行内框的高度。由一行形成的水平框称为行框(Line Box),行框的高度总是足以容纳它包含的所有行内框。不过,设置行高可以增加这个框的高度。
2》position属性:
定位:相对于此元素的正常位置;
相对于此元素的父元素;
相对于另一个元素;
相对于浏览器窗口本身位置;
一切皆为框:块框(块级元素);行内框(行内元素);
display修改框类型:block;inline;inline-block;none(生成的元素无框,即该框不展示,不占用文档空间)
但是在一种情况下,即使没有进行显式定义,也会创建块级元素。这种情况发生在把一些文本添加到一个块级元素(比如 div)的开头。即使没有把这些文本定义为段落,它也会被当作段落对待(说的是下边的some text还是整个div???):
some text
Some more text.
在这种情况下,这个框称为无名块框(匿名块框),因为它不与专门定义的元素相关联。(应该说的是some text这块内容)
匿名块框:当在块框前添加文本时,会将这些文本定义为块级元素,形成匿名块框。
例如:
这里的文本会形成匿名块框!这段内容即为匿名块框
行内框(inline box):每个行内元素会生成一个行内框;只是一个概念,它无法显示出来,但是它又确实存在;它的高度就是行高;在没有其他因素(padding)影响的时候,行内框等于内容区域。
tip:能通过border侧面烘托出行内框区域;
- 行框(line box):同行内框类似,行框是指本行的一个虚拟的矩形框 ;行框高度等于本行内所有元素中行高最大的值。
-
行高(line-height):行高就是等于行与行间的基线距离的文本高度;
https://www.cnblogs.com/dolphinX/p/3236686.html(写的比较好的)
position取值:
Static:默认值。没有定位,元素出现在正常的流中(忽略 top, bottom, left, right 或者 z-index 声明)。
元素正常生成;
Relative:生成相对定位的元素,相对于其正常位置进行定位。
因此,"left:20" 会向元素的 LEFT 位置添加 20 像素。
元素框偏移某个距离。元素仍保持其未定位前的形状,它原本所占的空间仍保留
h2.pos_left
{
position:relative;
left:-20px
}
absolute:生成绝对定位的元素,相对于 static 定位以外的第一个父元素进行定位。
元素的位置通过 "left", "top", "right" 以及 "bottom" 属性进行规定。
元素从文档流完全删除,相对于其包含快定位。包含块可能是文档中的另一个元素或初始包含块。元素原先在正常文档流中占的空间会关闭,好像元素不存在一样。元素定位后生成一个块级框,而不论原来它在正常流中生成何种类型的框。
h2.pos_abs
{
position:absolute;
left:100px;
top:150px
}
Fixed:生成绝对定位的元素,相对于浏览器窗口进行定位。
元素的位置通过 "left", "top", "right" 以及 "bottom" 属性进行规定。
表现类似于abosolute,不过其包含块是视窗本身。(相对于浏览器窗口来对元素进行定位)生成块级元素
p.one
{
position:fixed;
left:5px;
top:5px;
}
固定值:
百分比:
像素:
处理超出内容的情况:overflow(溢出);clip(剪切)
3》overflow属性:溢出
3.1》scroll(滚动展示溢出内容):
元素内容太大而超出规定区域时,如何设置溢出属性来规定相应的动作
3.2》hidden(隐藏溢出内容):
元素中的内容太大以至于无法适应指定的区域时,如何设置 overflow 属性来隐藏其内容
3.3》 auto
设置浏览器来自动地处理溢出
注:这个属性定义溢出元素内容区的内容会如何处理。如果值为 scroll,不论是否需要,用户代理都会提供一种滚动机制。因此,有可能即使元素框中可以放下所有内容也会出现滚动条。默认值是 visible。
4》clip属性:剪切
设置元素的形状。此元素被剪裁到这个形状内,并显示出来
img
{
position:absolute;
clip:rect(0px 50px 200px 0px)
}
5》vertical-align 在文本中垂直排列图象
取值:top;middle;baseline;bottom
6》z-index:z-index 属性设置元素的堆叠顺序。拥有更高堆叠顺序的元素总是会处于堆叠顺序较低的元素的前面;Z-index 仅能在定位元素上奏效;该属性设置一个定位元素沿 z 轴的位置,z 轴定义为垂直延伸到显示区的轴。如果为正数,则离用户更近,为负数则表示离用户更远。
默认的 z-index 是 0。Z-index -1 拥有更低的优先级;Z-index 1 拥有更高的优先级
21、css相对定位:
Relative:元素“相对于”它的起点进行移动
注意,在使用相对定位时,无论是否进行移动,元素仍然占据原来的空间。因此,移动元素会导致它覆盖其它框。
#box_relative {
position: relative;
left: 30px;
top: 20px;
}
22、css绝对定位:
设置为绝对定位的元素框从文档流完全删除,并相对于其包含块定位,包含块可能是文档中的另一个元素或者是初始包含块。元素原先在正常文档流中所占的空间会关闭,就好像该元素原来不存在一样。元素定位后生成一个块级框,而不论原来它在正常流中生成何种类型的框
绝对定位使元素的位置与文档流无关,因此不占据空间。这一点与相对定位不同,相对定位实际上被看作普通流定位模型的一部分,因为元素的位置相对于它在普通流中的位置。普通流中其它元素的布局就像绝对定位的元素不存在一样。
绝对定位的元素的位置相对于最近的已定位祖先元素(相对或绝对定位都包括在内),如果元素没有已定位的祖先元素,那么它的位置相对于最初的包含块。
对于定位的主要问题是要记住每种定位的意义。所以,现在让我们复习一下学过的知识吧:相对定位是“相对于”元素在文档中的初始位置,而绝对定位是“相对于”最近的已定位祖先元素,如果不存在已定位的祖先元素,那么“相对于”最初的包含块。
注释:根据用户代理的不同,最初的包含块可能是画布或 HTML 元素。
提示:因为绝对定位的框与文档流无关,所以它们可以覆盖页面上的其它元素。可以通过设置 z-index 属性来控制这些框的堆放次序。
23、css浮动:float:float 属性定义元素在哪个方向浮动。以往这个属性总应用于图像,使文本围绕在图像周围,不过在 CSS 中,任何元素都可以浮动,浮动元素会生成一个块级框,而不论它本身是何种元素
浮动的框可以左右移动,直到它的外边缘碰到包含框或另一个浮动框的边框为止。浮动框不在文档的普通流中,所以文档的普通流中的块框表现的就像浮动框不存在一样。如果浮动非替换元素,则要指定一个明确的宽度;否则,它们会尽可能地窄。
取值:left right none(默认值)
1》当把框 1 向右浮动时,它脱离文档流并且向右移动,直到它的右边缘碰到包含框的右边缘
2》当框 1 向左浮动时,它脱离文档流并且向左移动,直到它的左边缘碰到包含框的左边缘。因为它不再处于文档流中,所以它不占据空间,实际上覆盖住了框 2,使框 2 从视图中消失
3》如果把所有三个框都向左移动,那么框 1 向左浮动直到碰到包含框,另外两个框向左浮动直到碰到前一个浮动框
4》如果包含框太窄,无法容纳水平排列的三个浮动元素,那么其它浮动块向下移动,直到有足够的空间
5》如果浮动元素的高度不同,那么当它们向下移动时可能被其它浮动元素“卡住”
24、css选择器:
元素选择器(类型选择器):h1 {color:blue;}
CSS 元素选择器(类型选择器)可以设置 XML 文档中元素的样式
25、css选择器分组:
h2, p {color:gray;}
body, h2, p, table, th, td, pre, strong, em {color:gray;}
26、通配符选择器:* 该选择器可以和任何元素匹配,就像一个通配符。
* {color:red;} 此规则可以使文档中的每个元素都为红色
这个声明等价于列出了文档中所有元素的一个分组选择器。利用通配选择器,只需敲一次键(仅一个星号)就能使文档中所有元素的 color 属性值指定为 red
27、类选择器:
1》普通类选择器:
.important {color:red;}
2》结合元素选择器:
p.important {color:red;}
3》多类选择器:
一个 class 值中可能包含一个词列表,各个词之间用空格分隔。例如,如果希望将一个特定的元素同时标记为重要(important)和警告(warning),就可以写作
例:class 为 important 的所有元素都是粗体,而 class 为 warning 的所有元素为斜体,class 中同时包含 important 和 warning 的所有元素还有一个银色的背景 。就可以写作:
.important {font-weight:bold;}
.warning {font-style:italic;}
.important.warning {background:silver;}
This paragraph is very important.
This is a warning.
This paragraph is a very important warning.
注:通过把两个类选择器链接在一起,仅可以选择同时包含这些类名的元素(类名的顺序不限);如果一个多类选择器包含类名列表中没有的一个类名,匹配就会失败;.important.urgent {background:silver;}
不出所料,这个选择器将只匹配 class 属性中包含词 important 和 urgent 的 p 元素。因此,如果一个 p 元素的 class 属性中只有词 important 和 warning,将不能匹配。不过,它能匹配以下元素:
This paragraph is a very important and urgent warning.
28、id选择器:
1》
#intro {font-weight:bold;}
This is a paragraph of introduction.
2》类选择器与id选择器区别:
2.1》与类不同,在一个 HTML 文档中,ID 选择器会使用一次,而且仅一次;
2.2》不同于类选择器,ID 选择器不能结合使用,因为 ID 属性不允许有以空格分隔的词列表;
2.3》类似于类,可以独立于元素来选择 ID;
29、属性选择器:根据元素的属性或属性的值来选择元素。
1》简单属性选择器:
1.1》把包含标题(title)的所有元素变为红色:[title] {color:red;}或*[title] {color:red;}
对有 href 属性的锚(a 元素)应用样式:a[href] {color:red;}
1.2》可以根据多个属性进行选择,只需将属性选择器链接在一起即可:a[href][title] {color:red;}
1.3》为 XML 文档使用属性选择器
2》根据具体属性值选择:
2.1》a[href="http://www.w3school.com.cn/about_us.asp"] {color: red;}
2.2》a[href="http://www.w3school.com.cn/"][title="W3School"] {color: red;}
2.3》XML 语言也可以利用这种方法来设置样式
注意:属性与属性值必须完全匹配:这种格式要求必须与属性值完全匹配;如果属性值包含用空格分隔的值列表,匹配就可能出问题。
This paragraph is a very important warning.
如果写成 p[class="important"],那么这个规则不能匹配示例标记。
要根据具体属性值来选择该元素,必须这样写:
p[class="important warning"] {color: red;}
3》根据部分属性值选择:
3.1》如果需要根据属性值中的词列表的某个词进行选择,则需要使用波浪号(~)想选择 class 属性中包含 important 的元素:p[class~="important"] {color: red;}
~=
|=
3.2》子串匹配属性选择器
[abc^="def"]选择 abc 属性值以 "def" 开头的所有元素
[abc$="def"]选择 abc 属性值以 "def" 结尾的所有元素
[abc*="def"]选择 abc 属性值以 "def" 包含的所有元素:a[href*="w3school.com.cn"] {color: red;}
3.3》特定属性选择器:
*[lang|="en"] {color: red;}会选择 lang 属性等于 en ;或以 en- 开头的所有元素
HTML 文档中有一系列图片,其中每个图片的文件名都形如 figure-1.jpg 和 figure-2.jpg。就可以使用以下选择器匹配所有这些图像:img[src|="figure"] {border: 1px solid gray;}
30、css后代选择器(包含选择器):a b{}
有关后代选择器有一个易被忽视的方面,即两个元素之间的层次间隔可以是无限的;如果写作 ul em,这个语法就会选择从 ul 元素继承的所有 em 元素,而不论 em 的嵌套层次多深;
31、子元素选择器:a>b{}(>左右两边可以有也可以无空格)
a元素与b元素必须紧紧相邻,中间不能隔代
集合后代选择器:table.company td > p
32、相邻兄弟选择器:a+b{}(+左右两边可以有也可以无空格)
可选择紧邻在另一个元素后的元素(注意只是紧挨着的一个元素),且二者有相同的父元素
用一个结合符只能选择两个相邻兄弟中的第二个元素
结合其他选择器:html > body table + ul {margin-top:20px;}
33、伪类:用于向某些选择器添加特殊效果:
1》a (link;visited;hover;active )
a:link {color: #FF0000}
a:visited {color: #00FF00}
a:hover {color: #FF00FF}
a:active {color: #0000FF}
a.one:link {color: #ff0000}
a.one:visited {color: #0000ff}
a.one:hover {color: #ffcc00}
2》focus伪类 (焦点)
input:focus
{
background-color:yellow;
}
如果已规定 !DOCTYPE,那么 Internet Explorer 8 (以及更高版本)支持 :focus 伪类。
34、first-child伪类 (首个子对象)(必须声明 ,这样 :first-child 才能在 IE 中生效。)
p:first-child {font-weight: bold;}
li:first-child {text-transform:uppercase;}
p > em:first-child
{
font-weight:bold
}
p:first-child em
{
font-weight:bold
}
35、lang伪类(语言)如果已规定 !DOCTYPE,那么 Internet Explorer 8 (以及更高版本)支持 :lang 伪类。
lang 伪类允许您为不同的语言定义特殊的规则。在下面的例子中,在下面的例子中,:lang 类为带有值为 "no" 的 lang 属性的 q 元素定义引号的类型
q:lang(no)
{
quotes: "~" "~"
}
一些文本 段落中的引用 一些文本。
伪类语法:selector : pseudo-class {property: value}
Css类与伪类搭配:selector.class : pseudo-class {property: value}
锚伪类:a标签的状态
a:link {color: #FF0000} /* 未访问的链接 */
a:visited {color: #00FF00} /* 已访问的链接 */
a:hover {color: #FF00FF} /* 鼠标移动到链接上 */
a:active {color: #0000FF} /* 选定的链接 */
伪类总结:
:active向被激活的元素添加样式。(css1)
:focus向拥有键盘输入焦点的元素添加样式。(css2 需要声明)
:hover当鼠标悬浮在元素上方时,向元素添加样式。(css1)
:link向未被访问的链接添加样式。(css1)
:visited向已被访问的链接添加样式。(css1)
:first-child向元素的第一个子元素添加样式。(css2必须需声明才能用于IE)
:lang向带有指定 lang 属性的元素添加样式。(css2需要声明)
36、伪元素:
1》:first-line
注释:"first-line" 伪元素只能用于块级元素。
下列属性可用于first-line伪元素
- font
- color
- background
- word-spacing
- letter-spacing
- text-decoration
- vertical-align
- text-transform
- line-height
- clear
2》:first-letter
注释:"first-letter" 伪元素只能用于块级元素。
注释:下面的属性可应用于 "first-letter" 伪元素:
- font
- color
- background
- margin
- padding
- border
- text-decoration
- vertical-align (仅当 float 为 none 时)
- text-transform
- line-height
- float
- clear
3》伪元素和css类:
伪元素和css类配合使用:
p.article:first-letter
{
color: #FF0000;
}
This is a paragraph in an article。
4》多重伪元素:结合多个伪元素来使用
p:first-letter
{
color:#ff0000;
font-size:xx-large;
}
p:first-line
{
color:#0000ff;
font-variant:small-caps;
}
You can combine the :first-letter and :first-line pseudo-elements to add a special effect to the first letter and the first line of a text!
5》:before伪元素:":before" 伪元素可以在元素的内容前面插入新内容;默认地,这个伪元素是行内元素,不过可以使用属性 display 改变这一点。
h1:before
{
content:url(logo.gif);//插入图片
}
h1:before {content:"ddsd"} //插入ddsd内容
6》:after伪元素:":after" 伪元素可以在元素的内容之后插入新内容;默认地,这个伪元素是行内元素,不过可以使用属性 display 改变这一点。
h1:after
{
content:url(logo.gif);
}
h1:after {content:"ddsd"} //插入ddsd内容
37、css对齐:
1》margin 水平对齐
左右margin设为auto来对齐块元素
把左和右外边距设置为 auto,规定的是均等地分配可用的外边距。结果就是居中的元素
.center{
margin-left:auto;
margin-right:auto;
width:70%;
background-color:#b0e0e6;
}
2》position 左右对齐
.right{
position:absolute;
right:0px;
width:300px;
background-color:#b0e0e6;
}
3》float左右对齐
.right{
float:right;
width:300px;
background-color:#b0e0e6;
}
38、css尺寸
width(auto ;px;%); height(auto ;px;%;) ;max-height(none;px;%);max-width(none;px;%);min-height(0;px;%);min-width(none;px;%);line-height(normal;%;px;数值)
39、css分类:允许你规定如何及在何处显示元素。
CSS 分类属性允许你控制如何显示元素,设置图像显示于另一元素中的何处,相对于其正常位置来定位元素,使用绝对值来定位元素,以及元素的可见度。
1》display:inline(内联); none (不展示);block(块级)
2》float:
3》visibility:visible;hidden
4》改变光标:cursor: auto;crosshair;default;pointer;move;e-resize ;ne-resize;nw-resize;n-resize;se-resize;sw-resize;s-resize;w-resize;text;wait;help
5》clear 设置一个元素的侧面是否允许其他的浮动元素。
clear设置一个元素的侧面是否允许其他的浮动元素。left(左侧不允许浮动); right(右侧不允许浮动); both (左右两侧均不允许浮动);none(允许浮动出现在两侧)
cursor规定当指向某元素之上时显示的指针类型。
display设置是否及如何显示元素。
float定义元素在哪个方向浮动。
position把元素放置到一个静态的、相对的、绝对的、或固定的位置中。
visibility设置元素是否可见或不可见。
40、css导航条:
用ul 及li转化的
41、css图片库:
42、css图像透明度:
img{
opacity:0.4;
filter:alpha(opacity=40); /* For IE8 and earlier */
}
img:hover{
opacity:1.0;
filter:alpha(opacity=100); /* For IE8 and earlier */
}
IE9, Firefox, Chrome, Opera 和 Safari 使用属性 opacity 来设定透明度。opacity 属性能够设置的值从 0.0 到 1.0。值越小,越透明。
IE8 以及更早的版本使用滤镜 filter:alpha(opacity=x)。x 能够取的值从 0 到 100。值越小,越透明。
43、css媒介类型:媒介类型(Media Types)允许你定义以何种媒介来提交文档。文档可以被显示在显示器、纸媒介或者听觉浏览器等等。
@media规则:
@media screen//浏览器字体和字体类型展示
{
p.test {font-family:verdana,sans-serif; font-size:14px}
}
@media print//打印时字体和字体类型展示
{
p.test {font-family:times,serif; font-size:10px}
}
@media screen,print//浏览器和打印时 字体
{
p.test {font-weight:bold}
}
不同媒介:
All 所有媒介设备;
Aural 语音和音频合成器
Braille 盲人用点字法触觉回馈设备
Embossed 用于分页的盲人用点字法打印机
handheld 用于小的手持的设备。
print 用于打印机。
projection 用于方案展示,比如幻灯片。
screen 用于电脑显示器。
tty 用于使用固定密度字母栅格的媒介,比如电传打字机和终端。
tv 用于电视机类型的设备。
44、css注意事项:
Internet Explorer Behaviors:behaviors 是一种通过使用 CSS 向 HTML 元素添加行为的方法;为什么要避免它?只有 Internet Explorer 支持 behavior 属性;
==================================
js
1、js输出:
window.alert() 写入警告框 ;document.getElementById("demo").innerHTML = 5 + 6;
document.write() 写入 HTML 输出; document.write(5 + 6); 测试用 ;
1》在文档加载完后使用document.write()将删除所有HTML(即在window.onlaod函数中调用时)
2》
innerHTML 写入 HTML 元素;document.getElementById("demo").innerHTML = 5 + 6;
console.log() 写入浏览器控制台;
2、js语句:
3、js语法:
Js值:混合值(字面量); 变量值(变量)
Js数据类型:
可包含值的数据类型:string;number;boolean;object;function
对象类型:Object;Date;Array
不包含值的数据类型:null;undefined;
无法使用 typeof 去判断 JavaScript 对象是否是数组(或日期)。
4、js运算符:
4.1》+= 赋值运算符也可用于相加(级联)字符串:txt1 = "Hello "; txt1 += "Kitty!";
4.2》类型运算符:typeof; instanceof(返回 true,如果对象是对象类型的实例。)
4.3》逻辑运算符 &&(逻辑与) ||(逻辑或) !(逻辑非)
4.4》位运算符:&; |; ~(非);^;<<(零填充左位移);>>(有符号右位移);>>>(零填充右位移)
5、算数:
算数运算符:
1》**幂 var z = x ** 2; // 结果是 25
var z = Math.pow(x,2); // 结果是 25
2》in 对象中的属性 "PI" in Math
3》yield暂停函数 yield x
6、赋值运算符:
x %= y 即 x = x % y
x <<= y 即 x = x << y
x >>= y 即 x = x >> y
x >>>= y即x = x >>> y
x &= y即x = x & y
x ^= y x = x ^ y
x |= y x = x | y
x **= y x = x ** y
>>> 右位移(无符号)
6、js数据类型:
1》Js拥有动态类型:即相同变量可用作不同类型
var x;
x = 7;
x = “bill”
变量x从number转换为string类型
2》字符串:string
3》js数值:number
超大或超小都可以用科学计数法来写:
var y = 123e5; //12300000
Var z = 123e-5;//0.00123
4》js布尔:
5》数组:array
6》对象:object
typeof运算符:
数组-object(js中数组属于对象)
7》Undefined:
7.1》无值的变量值为undefined;typeof返回undefined
eg:var person;//值和类型分别是undefined和undefined
7.2》任何变量可以通过设置为undefined进行清空。其类型也是undefined
eg:person = undefined;//值和类型分别是undefined和undefined
8》空值:
与undefined不一回事;例如空的字符串变量既有值也有类型;eg var str= “”;//值是“”,类型是string
9》Null:是object类型;也可以用来清空对象
10》Null与Undefined区别:==返回true;类型不同
typeof undefined // undefined
typeof null // object
null === undefined // false
null == undefined // true
11》
11.1》 原始数据:typeof返回string number boolean undefined
11.2》 复杂数据:typeof返回function object
typeof 数组/对象/null为 object;
typeof 函数 function
原始类型:Undefined、Null、Boolean、Number 、 String
typeof原始类型:undefined、object、boolean、number、string
Undefined类型:Undefined 类型只有一个值,即 undefined。当声明的变量未初始化或未定义时,该变量的默认值是 undefined。如果对为声明的变量使用除 typeof 之外的其他运算符的话,会引起错误,因为其他运算符只能用于已声明的变量上。
Null类型:另一种只有一个值的类型是 Null,它只有一个专用值 null,即它的字面量。值 undefined 实际上是从值 null 派生来的;alert(null == undefined); //输出 "true"尽管这两个值相等,但它们的含义不同。undefined 是声明了变量但未对其初始化时赋予该变量的值,null 则用于表示尚未存在的对象(在讨论 typeof 运算符时,简单地介绍过这一点)。如果函数或方法要返回的是对象,那么找不到该对象时,返回的通常是 null。
Boolean类型:
Number类型:整数;浮点数(对于浮点字面量的有趣之处在于,用它进行计算前,真正存储的是字符串。);科学计数法;(ECMAScript 默认把具有 6 个或 6 个以上前导 0 的浮点数转换成科学计数法。);
八进制和十六进制:尽管所有整数都可以表示为八进制或十六进制的字面量,但所有数学运算返回的都是十进制结果。
特殊Number值:几个特殊值也被定义为 Number 类型。
1》前两个是 Number.MAX_VALUE 和 Number.MIN_VALUE,它们定义了 Number 值集合的外边界。所有 ECMAScript 数都必须在这两个值之间。不过计算生成的数值结果可以不落在这两个值之间;当计算生成的数大于 Number.MAX_VALUE 时,它将被赋予值 Number.POSITIVE_INFINITY,意味着不再有数字值。同样,生成的数值小于 Number.MIN_VALUE 的计算也会被赋予值 Number.NEGATIVE_INFINITY,也意味着不再有数字值。如果计算返回的是无穷大值,那么生成的结果不能再用于其他计算。
事实上,有专门的值表示无穷大:infinity;有专门值表示无穷小:-infinity;对任何数调用 isFinite() 方法,以确保该数不是无穷大;
2》NaN:表示非数;alert(NaN == NaN); //输出 "false"
isNaN(“666”) //false 参数是数字则返回false
String类型:是唯一没有固定大小的原始类型;
7、类型转换:
1》转换成字符串:Boolean 值、数字和字符串的原始值的有趣之处在于它们是伪对象,这意味着它们实际上具有属性和方法。
1.1》toString():Boolean;Number;String都可以用此方法,可以把它们的值转换成字符串;
1.1.1》Number 类型的 toString()(默认模式/基模式):
默认模式:返回的都是数字的十进制表示。因此,以八进制或十六进制字面量形式声明的数字输出的都是十进制形式的;var iNum1 = 10;alert(iNum1.toString()); //输出 "10"
基模式:可以用不同的基输出数字,例如二进制的基是 2,八进制的基是 8,十六进制的基是 16。var iNum = 10;alert(iNum.toString(2));//输出"1010"alert(iNum.toString(8)); //输出 "12"alert(iNum.toString(16)); //输出 "A"
1.1.2》Array类型的toString() 与数组的join()无参方法作用相同
var arrayStr = array.toString();console.log(arrayStr,typeof arrayStr);
当数组用于字符串环境时,JavaScript 会调用这一方法将数组自动转换成字符串。但是在某些情况下,需要显式地调用该方法。
1.1.3》boolean类型的toString()
返回 true 或 false 在 Boolean 对象被用于字符串环境中时,此方法会被自动调用。
1.1.4》Date类型的toString()
var d = new Date();var dateStr = d.toString();
1.1.5》函数的toString()等于valueof() 返回结果为函数的描述
1.2》toLocalString():得到本地格式的字符串数据
2》转换数字:
2.1》parseInt())只有对string类型调用这些方法,他们才能正确运行;对其他类型返回的都是NaN;
默认模式:
基模式:如果十进制数包含前导 0,那么最好采用基数 10,这样才不会意外地得到八进制的值
2.2》parseFloat(注:使用 parseFloat() 方法的另一不同之处在于,字符串必须以十进制形式表示浮点数,而不是用八进制或十六进制。该方法会忽略前导 0,所以八进制数 0102 将被解析为 102。对于十六进制数 0xA,该方法将返回 NaN,因为在浮点数中,x 不是有效字符。(注释:经测试,具体的浏览器实现会返回 0,而不是 NaN。)parseFloat() 方法也没有基模式
3》强制类型转换:
Boolean(value) - 把给定的值转换成 Boolean 型;当要转换的值是至少有一个字符的字符串、非 0 数字或对象时,Boolean() 函数将返回 true。如果该值是空字符串、数字 0、undefined 或 null,它将返回 false;
Number(value) - 把给定的值转换成数字(可以是整数或浮点数):Number() 函数的强制类型转换与 parseInt() 和 parseFloat() 方法的处理方式相似,只是它转换的是整个值,而不是部分值;Number() 进行强制类型转换,"1.2.3" 将返回 NaN,如果字符串值能被完整地转换,Number() 将判断是调用 parseInt() 方法还是 parseFloat() 方法
String(value) - 把给定的值转换成字符串
8、js函数:
1》函数在加()是函数的调用;如果不加括号则引用的是函数对象;
2》局部变量:在函数中声明的变量,只能在函数内访问。
3》、Function对象(类):
3.1》直接创建函数:
var function_name = new function(arg1, arg2, ..., argN, function_body)
在上面的形式中,每个 arg 都是一个参数,最后一个参数是函数主体(要执行的代码)。这些参数必须是字符串。
function sayHi(sName, sMessage) {
alert("Hello " + sName + sMessage);
}
等价于:
var sayHi = new Function("sName", "sMessage", "alert(\"Hello \" + sName + sMessage);");
注意:尽管可以使用 Function 构造函数创建函数,但最好不要使用它,因为用它定义函数比用传统方式要慢得多。不过,所有函数都应看作 Function 类的实例。
3.2》Function对象的length:函数期望的参数个数,即形参个数。
3.3》Function对象的方法:valueof() toString()
function doAdd(iNum) {
alert(iNum + 10);
}
document.write(doAdd.toString());
document.write(doAdd.valueOf());
结果都是函数的源代码function doAdd(iNum) { alert(iNum + 10); }
4》arguments对象:函数实参组成的数组;
4.1》
function howManyArgs() {
alert(arguments.length);
}
howManyArgs("string", 45);//2
howManyArgs();//0
howManyArgs(12);//1
注释:与其他程序设计语言不同,ECMAScript 不会验证传递给函数的参数个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数(根据 Netscape 的文档,最多可接受 255 个),而不会引发任何错误。任何遗漏的参数都会以 undefined 传递给函数,多余的函数将忽略。
4.2》可以模拟重载:
function doAdd() {
if(arguments.length == 1) {
alert(arguments[0] + 5);
} else if(arguments.length == 2) {
alert(arguments[0] + arguments[1]);
}
}
doAdd(10); //输出 "15"
doAdd(40, 20); //输出 "60"
5》闭包:函数可以使用函数之外定义的变量
简单闭包:在 ECMAScript 中使用全局变量是一个简单的闭包实例。
var sMessage = "hello world";
function sayHelloWorld() {
alert(sMessage);
}
sayHelloWorld();
复杂闭包:在一个函数中定义另一个会使闭包变得更加复杂
var iBaseNum = 10;
function addNum(iNum1, iNum2) {
function doAdd() {
return iNum1 + iNum2 + iBaseNum;
}
return doAdd();
}
闭包由两部分构成:函数,以及创建该函数的环境。环境由闭包创建时在作用域中的任何局部变量组成。
外部函数调用之后其变量对象本应该被销毁,但闭包的存在使我们仍然可以访问外部函数的变量对象,这就是闭包的重要概念。
闭包一般都是函数嵌套函数
在javascript中,如果一个对象不再被引用,那么这个对象就会被垃圾回收机制回收;
如果两个对象互相引用,而不再被第3者所引用,那么这两个互相引用的对象也会被回收。
这里要理解函数名与函数功能是分割开的,不要认为函数在哪里,其内部的this就指向哪里。这里要理解函数名与函数功能是分割开的,不要认为函数在哪里,其内部的this就指向哪里。
闭包:https://www.jianshu.com/p/102e44f35b3b
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Closures
9、this关键字:this关键字是它所属的对象;
其位置不同,则取值不同:
1》方法中,this指的是所有者对象;
2》单独情况,this指全局对象;
3》函数中,this是全局对象;
4》函数中,严格模式下,this是undefined;
5》事件中,this指的是接收事件的元素;
向call(),applay()这样的方法可以将this引用到任何对象
var person1 = {
fullName: function() {
return this.firstName + " " + this.lastName;
}
}
var person2 = {
firstName:"Bill",
lastName: "Gates",
}
person1.fullName.call(person2); // 会返回 "Bill Gates"
10、js对象
对象应用:
声明和实例化:
var oObject = new Object();
var oStringObject = new String();
如果构造函数无参数,括号则不是必需的,因此可以采用下面的形式重写上面的两行代码:
var oObject = new Object;
var oStringObject = new String;
对象引用:引用类型
对象废除:ECMAScript拥有无用存储单元收集程序,即不必专门销毁对象来释放内存。当没有对对象的引用时,该对象被废除。运行无用存储单元收集程序时,所有废除的对象都被销毁。每当函数执行完它的代码,无用存储单元收集程序都会运行,释放所有的局部变量,还有在一些其他不可预知的情况下,无用存储单元收集程序也会运行。
对象所有引用设为null,可强制废除对象。var oObject = new Object;oObject = null;
注意:废除对象的所有引用时要当心。如果一个对象有两个或更多引用,则要正确废除该对象,必须将其所有引用都设置为 null。
绑定:即把对象的接口与对象实例结合在一起的方法。
晚绑定:指的是编译器或解释程序在运行前,不知道对象的类型,使用晚绑定,无需检查对象的类型,只需检查对象是否支持属性和方法即可。ECMAScript 中的所有变量都采用晚绑定方法。这样就允许执行大量的对象操作,而无任何惩罚。
请不要把字符串、数值和布尔值声明为对象:
通过关键词 "new" 来声明 JavaScript 变量,则该变量会被创建为对象;
请避免字符串、数值或逻辑对象。他们会增加代码的复杂性并降低执行速度;
11、ECMAScript引用类型:引用类型通常叫做class,也就是说,遇到引用值,所处理的就是对象。
1、Object对象具有如下属性:
constructor:对创建对象的函数的引用(指针)。对于object对象,该指针指向原始的Object()函数;对于字面量对象,该指针指向原始的Object()函数;如果是自定义构造函数,则该指针指向此构造函数;
prototype:对该对象的对象原型的引用。对于所有对象,它默认返回Object对象的一个实例。
Object对象的其他方法:
1》hasOwnProperty(“属性名”):判断对象是否有某个特定属性。必须用字符串指定该属性。(例如:o.hasOwnProperty(“name”))
console.log(bird.hasOwnProperty('name'),bird.hasOwnProperty('major'),Bird.hasOwnProperty('name’));(注:没有 bird.prototype.hasOwnProperty('name’)这种写法)
2》IsPrototypeOf(object):判断该对象是否为另一个对象的原型。console.log(Bird.prototype.isPrototypeOf(bird),Object.prototype.isPrototypeOf(bird));
3》PropertyIsEnumerable 判断给定的属性是否可以用 for...in 语句进行枚举。(通过secondConstructor.prototype = new firstConstructor;
secondConstructor.prototype.constructor = secondConstructor;
方式继承的属性的PropertyIsEnumerable值为false,但却能通过for…in遍历出来(特殊))
for...in语句以任意顺序遍历一个对象的可枚举属性。对于每个不同的属性,语句都会被执行。
如果一个对象的属性不是可枚举属性,那么这个属性就不会被for...in迭代出来,包括继承的可枚举属性。
每个对象都有一个propertyIsEnumerable方法。此方法可以确定对象中指定的属性是否可以被for...in循环枚举,但是通过原型链继承的属性除外。如果对象没有指定的属性,则此方法返回false。
可枚举: 如果一个属性可以使用for in 能遍历出,就是可枚举的。
1、可枚举属性是指那些内部 “可枚举” 标志设置为 true 的属性,对于通过直接的赋值和属性初始化的属性,该标识值默认为即为 true
2、对于通过 Object.defineProperty 等定义的属性,该标识值默认为 false。
3、可枚举的属性可以通过 for...in 循环进行遍历(除非该属性名是一个 Symbol)。属性的所有权是通过判断该属性是否直接属于某个对象决定的,而不是通过原型链继承的。
4、继承属性如果是可枚举属性也能被迭代出来
5、原型属性原则上是不可枚举的
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable
https://www.jianshu.com/p/305459cabcbd
https://www.cnblogs.com/SourceKing/p/5760050.html
https://blog.csdn.net/qq_44034384/article/details/92018303
2、Boolean对象:
var oBooleanObject = new Boolean(true);在 ECMAScript 中很少使用 Boolean 对象,即使使用,也不易理解。
创建Boolean对象的语法:
new Boolean(value);
3、Number对象:
//Number对象
var num = new Number(68);
var oriOfNum = num.valueOf();//得到数字对象的Number的原始值
//toFixed(n) 显示n为小数位,仅限于0~20
var toFixNum = num.toFixed(2);
var toFixNumm = num.toFixed(3);
//toExponential(n) 用科学计数法表示的数字的字符串形式
var toExp = num.toExponential(1);
//toPrecision(n) 表示数的数字总数(不包括指数)
var toPre = num.toPrecision(1);
var toPree = num.toPrecision(2);
var toPreee = num.toPrecision(3);
console.log(num,oriOfNum,toFixNum,toFixNumm,toExp,toPre,toPree,toPreee);
//结果:68 "68.00" "68.000" "6.8e+1" "7e+1" "68" "68.0"
4、String对象:
//String对象
var strO = new String('hello world')
var valueStr = strO.valueOf();
var toStrStr = strO.toString();
console.log(valueStr,typeof valueStr,toStrStr,typeof toStrStr)//hello world string hello world string
//字符串的字符个数
var strLen = strO.length;
console.log(strLen);//11
//charAt()
var d0 = strO.charAt(0);
console.log(d0);//h
//charCodeAt()
var d1 = strO.charCodeAt(0);
console.log(d1);//104
//concat() 拼接字符串到str上,原始值不变
var str1 = new String('hello');
var str2 = str1.concat('world');
console.log(str1,str2);//String {"hello"} "helloworld"
//+:调用 concat() 方法返回的是 "hello world",而 String 对象存放的仍然是 "hello "。出于这种原因,较常见的是用加号(+)连接字符串,因为这种形式从逻辑上表明了真正的行为
var str3 = new String('hello');
var str4 = str3 + 'world';
var strr = 'hello'
console.log(str3,str4,strr);//String {"hello"} "helloworld" "hello"
//indexof() lastIndexOf()
var index1 = strO.indexOf('o');
var index2 = strO.lastIndexOf('o');
var index3 = strO.indexOf('m');
var index4 = strO.lastIndexOf('m');
console.log(index1,index2,index3,index4)//4 7 -1 -1
// localeCompare() 是区分大小写;大写字母在字母顺序上排在小写字母之后
//如果 String 对象按照字母顺序排在参数中的字符串首字母之前,返回-1
//如果 String 对象等于参数中的字符串首字母之前,返回 0
//如果 String 对象按照字母顺序排在参数中的字符串首字母之前之后,返回1
var strY = 'eellow'
var one = strY.localeCompare('abc');//1
var two = strY.localeCompare('zoo');//-1
var three = strY.localeCompare('eellow');//0
var four = strY.localeCompare('Eellow')//-1
console.log(one,two,three,four);//1 -1 0 -1
//slice(),两个参数【起始index,终止index)
var sliceStr = strO.slice(1,3);
console.log(sliceStr);//el
//substring(),两个参数【起始index,终止index)
var subString = strO.substring(1,3);
console.log(subString);//el
//slice()与subString()区别
// 处理负数时slice()会将负数+字符串长度;subString()会将负数以0处理
//substring() 方法则将两个参数解释为 substring(3, 0),实际上即 substring(0, 3),因为 substring() 总把较小的数字作为起始位,较大的数字作为终止位
var sr1 = strO.slice(-3);
var sr11 = strO.slice('-3');
var sr111 = strO.slice('3','-4');
var sr2 = strO.substring(-3);
var sr22 = strO.substring('3','-4');
var sr222 = strO.substring('1','-4');
console.log(sr1,sr11,sr111,sr2,sr22);//rld rld lo w hello world hel
console.log(sr111,'=',sr22,'=',sr222);//lo w = hel = h
//大小写转换
var s1 = strO.toLowerCase();
var s2 = strO.toLocaleLowerCase();
var s3 = strO.toUpperCase();
var s4 = strO.toLocaleUpperCase();
console.log(s1,s2,s3,s4);//hello world hello world HELLO WORLD HELLO WORLD
//instanceof运算符;与 typeof 方法不同的是,instanceof 方法要求开发者明确地确认对象为某特定类型,只有new String创建的字符串此值才为true
var bol = strO instanceof String;
console.log(bol);//true
var sdf = '都是对的';
var bol1 = sdf instanceof String;
console.log(bol1)//false
var bol2 = sdf instanceof Object;
console.log(bol2);//false
12、对象类型:
在ECMAScript中,所有对象并非等同创建。
可以创建并使用的对象分三种:本地对象、内置对象、宿主对象
12.1本地对象:本地对象就是 ECMA-262 定义的类(引用类型)
Object;
Function;
Array;
String;
Boolean;
Number;
Date;
RegExp;
Error;
EvalError;
RangeError;
ReferenceError;
SyntaxError;
TypeError;
URIError;
12.2内置对象:开发者不必明确实例化内置对象,它已被实例化,ECMA-262 只定义了两个内置对象,即 Global 和 Math (它们也是本地对象,根据定义,每个内置对象都是本地对象)
1》Global对象(全局对象):全局函数(顶层函数);全局属性(顶层属性)
全局对象是预定义的对象,作为 JavaScript 的全局函数和全局属性的占位符。通过使用全局对象,可以访问所有其他所有预定义的对象、函数和属性。全局对象不是任何对象的属性,所以它没有名称
Math对象;
在顶层 JavaScript 代码中,可以用关键字 this 引用全局对象。但通常不必用这种方式引用全局对象,因为全局对象是作用域链的头,这意味着所有非限定性的变量和函数名都会作为该对象的属性来查询。例如,当JavaScript 代码引用 parseInt() 函数时,它引用的是全局对象的 parseInt 属性。全局对象是作用域链的头,还意味着在顶层 JavaScript 代码中声明的所有变量都将成为全局对象的属性。
var test1="http://www.w3school.com.cn/My first/"
document.write(encodeURI(test1)+ " ")
document.write(decodeURI(test1))
2》Math对象:
var pi_value=Math.PI;
var sqrt_value=Math.sqrt(15);
12.3宿主对象:所有非本地对象都是宿主对象,所有BOM和DOM对象
RegExp:此对象表示正则表达式,匹配字符串;
1》RegExp对象:
直接量语法:/pattern/attributes
创建RegExp对象语法:new RegExp(pattern,attributes)
pattern:是正则表达式而不是字符串;
attributes:可选字符串;(g:全局匹配 i:区分大小写 m:多行匹配)
返回值:pattern 是正则表达式而不是字符串,RegExp() 构造函数将用与指定的 RegExp 相同的模式和标志创建一个新的 RegExp 对象。
不用 new 运算符,而将 RegExp() 作为函数调用,那么它的行为与用 new 运算符调用时一样,只是当 pattern 是正则表达式时,它只返回 pattern,而不再创建一个新的 RegExp 对象???。
抛出:
SyntaxError:如果pattern不是合法正则表达式,或attributes含i g m之外的字符,抛出该异常
TypeError:如果pattern是RegExp对象,但没有省略attributes,抛出该异常。
2》修饰符:匹配规则
i:执行对大小写不敏感的匹配。
g:执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)。
m:执行多行匹配。
3》方括号:用于查找某个范围内的字符:
[abc]:查找方括号之间的任何字符
[^abc]:查找任何不在方括号之间的字符
[0-9]:查找0-9的数字
[^0-9]:0-9以外的数字
[a-z]:a到z的字符
[A-Z]:A到Z的字符
[A-z]:A到z的字符
[adgk]:给定集合的任意字符
[^adgk]:给定集合外是任何字符
(red|blue|green):查找任何指定的选项
4》元字符:拥有特殊含义的字符
. 查找单个字符,除了换行和行结束符
\w 查找单词字符
\W 查找非单词字符
\d 查找数字
\D 查找非数字字符
\s 空白字符
\S 非空白字符
\b 匹配单词边界
\B 匹配非单词边界
\0 查找NUL字符
\n 查找换行符
\f 换页符
\r 回车符
\t 制表符
\v 垂直制表符
\xxx 八进制数xxx规定的字符
\xdd 十六进制数dd规定的字符
\uxxxx 十六进制数xxxx规定的Unicode字符
5》量词:
n+ 匹配任何包含至少一个n的字符串
n* 。。。。。。零个或多个n的字符串
n? 。。。。。。零个或一个n的字符串
n{X} 匹配包含X个n的序列的字符串
n{X,Y} 匹配包含X至Y个n的序列字符串
n{X,} 匹配包含至少X个n的序列字符串
n$ 匹配任何结尾为n的字符串
^n 。。。。以n开头的字符串
?=n 。。。。其后紧接指定字符串n的字符串
?!n 。。。。其后没有紧接指定字符串n的字符串
6》对象属性:
Global:RegExp对象是否有标志g,如果g标志被设置则为true,反之为false
ignoreCase:RegExp对象是否有标志i,如果i标志被设置则为true,反之为false
lastIndex:一个整数,标示开始下一次匹配的起始字符位置(重要事项:不具有标志 g 和不表示全局模式的 RegExp 对象不能使用 lastIndex 属性。提示:如果在成功地匹配了某个字符串之后就开始检索另一个新的字符串,需要手动地把这个属性设置为 0。)
multiline: RegExp对象是否有标志m,如果m标志被设置则为true,反之为false
source: 正则表达式的源文本
7》对象方法:
compile():编译正则表达式;改变和重新编译正则表达式
var str="Every man in the world! Every woman on earth!";
patt=/man/g;
str2=str.replace(patt,"person");
document.write(str2+" ");
patt=/(wo)?man/g;
patt.compile(patt);
str2=str.replace(patt,"person");
document.write(str2);
exec():检索字符串中指定的值。返回找到的值,并确定其位置
返回一个数组,其中存放匹配的结果。如果未找到匹配,则返回值为 null。
如果 exec() 找到了匹配的文本,则返回一个结果数组。否则,返回 null。此数组的第 0 个元素是与正则表达式相匹配的文本,第 1 个元素是与 RegExpObject 的第 1 个子表达式相匹配的文本(如果有的话),第 2 个元素是与 RegExpObject 的第 2 个子表达式相匹配的文本(如果有的话),以此类推。除了数组元素和 length 属性之外,exec() 方法还返回两个属性。index 属性声明的是匹配文本的第一个字符的位置。input 属性则存放的是被检索的字符串 string。我们可以看得出,在调用非全局的 RegExp 对象的 exec() 方法时,返回的数组与调用方法 String.match() 返回的数组是相同的。
但是,当 RegExpObject 是一个全局正则表达式时,exec() 的行为就稍微复杂一些。它会在 RegExpObject 的 lastIndex 属性指定的字符处开始检索字符串 string。当 exec() 找到了与表达式相匹配的文本时,在匹配后,它将把 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。这就是说,您可以通过反复调用 exec() 方法来遍历字符串中的所有匹配文本。当 exec() 再也找不到匹配的文本时,它将返回 null,并把 lastIndex 属性重置为 0。
例:
var str = "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School";
//2、局部RegExp
function testIvarRegExp() {
var patt = new RegExp("W3School","g");
var pattresult = patt.exec(str);
console.log(pattresult)
console.log('match',str.match('W3School'))
}
//1、全局RegExp
var patt = new RegExp("W3School","g");
var result;
while ((result = patt.exec(str)) != null) {
document.write(result);
document.write(" ");
document.write(patt.lastIndex);
document.write(" ");
console.log('result',result)
}
result ["W3School", index: 8, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:356 result ["W3School", index: 23, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:356 result ["W3School", index: 33, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:356 result ["W3School", index: 77, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:356 result ["W3School", index: 89, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:345
["W3School", index: 8, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
js-对象.html?_ijt=bn65ed7rc3griu7a6i6pnbf22c:346 match ["W3School", index: 8, input: "w3SchoolW3School Visit W3School, W3School is a place to study web technology.W3Schoolll W3School", groups: undefined]
提示:请注意,无论 RegExpObject 是否是全局模式,exec() 都会把完整的细节添加到它返回的数组中。这就是 exec() 与 String.match() 的不同之处,后者在全局模式下返回的信息要少得多。因此我们可以这么说,在循环中反复地调用 exec() 方法是唯一一种获得全局模式的完整模式匹配信息的方法。
test():检索字符串中指定值。返回true或false
RegExpObject.test(string)
var str = "Visit W3School";
var patt1 = new RegExp("W3School");
var result = patt1.test(str);
如果字符串 string 中含有与 RegExpObject 匹配的文本,则返回 true,否则返回 false。
8》支持正则表达式的String对象的方法:
search():方法用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串。
stringObject.search(regexp)如果没有找到任何匹配的子串,则返回 -1。
search() 方法不执行全局匹配,它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性,并且总是从字符串的开始进行检索,这意味着它总是返回 stringObject 的第一个匹配的位置
//支持正则表达式的String对象的方法
//1、search()
//返回值:stringObject 中第一个与 regexp 相匹配的子串的起始位置。如果没有找到任何匹配的子串,则返回 -1。
//
var str = 'Visit w3School W3School ffW3School teacher!'
var ind = str.search(/W3School/);
var pattern = new RegExp('W3School','i');
var ind1 = str.search(pattern);
var ind2 = str.search(/W3School/i);
var ind3 = str.search(/w3School/i);
var ind4 = str.search(/w3School/);
var ind5 = str.search(/W3School/g);
var ind6 = str.search(/Teacher/)
console.log(ind,ind1,ind2,ind3,ind4,ind5,ind6);
// 15 6 6 6 6 15 -1
//2、match() 找到一个或多个正则表达式的匹配
返回:存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。
match() 方法将检索字符串 stringObject,以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。
如果 regexp 没有标志 g,那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本, match() 将返回 null。否则,它将返回一个数组,其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本,而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外,返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置,input 属性声明的是对 stringObject 的引用。
如果 regexp 具有标志 g,则 match() 方法将执行全局检索,找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串,则返回 null。如果找到了一个或多个匹配子串,则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同,它的数组元素中存放的是 stringObject 中所有的匹配子串,而且也没有 index 属性或 input 属性。
//2.1 match()检索字符串:stringObject.match(searchvalue)
var strm="Hello world!"
var m1 = strm.match('world');
var m2 = strm.match('World');
var m3 = strm.match('worlld');
var m4 = strm.match('world!');
console.log(m1,m2,m3,m4);
// ["world", index: 6, input: "Hello world!", groups: undefined]
// null
// null
// ["world!", index: 6, input: "Hello world!", groups: undefined]
//2.2 match()检索正则表达式:stringObject.match(regexp)
var strmm = '1plus2equal3';
var patternM = new RegExp('\d','g');
var patternM1 = /\d+/g;
var mm1 = strmm.match(patternM);
var mm2 = strmm.match(patternM1);
console.log(mm1,mm2);
//3、replace() 方法用于在字符串中用一些字符替换另一些字符,或替换一个与正则表达式匹配的子串。
//stringObject.replace(regexp/substr,replacement)
//返回值:一个新的字符串,是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的
// regexp 具有全局标志 g,那么 replace() 方法将替换所有匹配的子串。否则,它只替换第一个匹配子串。
//第一个参数:规定子字符串或要替换的模式的 RegExp 对象,请注意,如果该值是一个字符串,则将它作为要检索的直接量文本模式,而不是首先被转换为 RegExp 对象
//第二个参数replacement:可以是字符串,也可以是函数;
//replacement中的$有特定含义
/**
* $1、$2、$3、$4、...、$99 与 regexp 中的第 1 到第 99 个子表达式相匹配的文本
* $& 与 regexp 相匹配的子串
* $` 位于匹配子串左侧的文本
* $' 位于匹配子串右侧的文本
* $$ 直接量符号
* 注意:ECMAScript v3 规定,replace() 方法的参数 replacement 可以是函数而不是字符串。在这种情况下,每个匹配都调用该函数,它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串,可以有 0 个或多个这样的参数。接下来的参数是一个整数,声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。
* */
// 3.1、替换字符串
var str="Visit Microsoft!"
console.log(str.replace(/Microsoft/, "W3School"));
// 3.2、替换字符串-全局替换
var str="Welcome to Microsoft! "
str=str + "We are proud to announce that Microsoft has "
str=str + "one of the largest Web Developers sites in the world."
console.log(str.replace(/Microsoft/g, "W3School"));
// 3.3、确保匹配字符串大写字符的正确
var text = "javascript Tutorial";
text.replace(/javascript/i, "JavaScript");
// 3.4、正则表达式+replacement参数中$符
var name = "Doe, John";
name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1");
// 3.5、正则表达式+replacement参数$符
name = '"a", "b"';
name.replace(/"([^"]*)"/g, "'$1'");
// 3.6、正则表达式+replacement参数为函数
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
return word.substring(0,1).toUpperCase()+word.substring(1);}
);
//4、split()把字符串分割为字符串数组
// stringObject.split(separator,howmany)
// 参数一:必需,字符串或正则表达式,从该参数指定的地方分割 stringObject
// 参数二:可选,该参数可指定返回的数组的最大长度。如果设置了该参数,返回的子串不会多于这个参数指定的数组。如果没有设置该参数,整个字符串都会被分割,不考虑它的长度
//返回值:一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。
// 但是,如果 separator 是包含子表达式的正则表达式,那么返回的数组中包括与这些子表达式匹配的字串(但不包括与整个正则表达式匹配的文本
//String.split() 执行的操作与 Array.join 执行的操作是相反的
//1》
var strSp = "How are you doing today?";
var sp1 = strSp.split('');
var sp2 = strSp.split(' ');
var sp3 = strSp.split(' ',3);
console.log(sp1,sp2,sp3);
//2》
var sp4 = '2:3:4:5'.split(':');
var sp5 = '|a|b|c'.split('|');
console.log(sp4,sp5);
// 3》
var sentence = 'I am a beautify girl';
var sp6 = sentence.split(' ');
var sp7 = sentence.split(/\s+/);
console.log(sp6,sp7);
2》Js Events
事件通常与函数配合使用;
onabort:图像加载被中断
onblur:元素失去焦点
onchange:用户改变阈的内容
onclick:鼠标点击某个对象
ondblclick:鼠标双击某个对象
onerror:当加载文档或图像时发生某个错误
onfocus:元素获得焦点
onkeydown:某个键盘的键被按下
onkeypress:某个键盘的键被按下或按住
onkeyup:某个键盘的键被松开
onload:某个页面或图像被完成加载
onmousedown:某个鼠标按键被按下
onmousemove:鼠标被移动
onmouseout:鼠标从某元素移开
onmouseover:鼠标被移到某元素之上
onmouseup:某个鼠标按键被松开
onreset:重置按钮被点击
onresize:窗口或框架被调整尺寸
onselect:文本被选定
onsubmit:提交按钮被点击
onunload:用户退出页面
13、js继承:/Users/yangyangzi/Desktop/YangZi2/2019前端/h5+css+js/testJS/html/js-继承.html(公司电脑)
https://www.cnblogs.com/liangxiaofeng/p/5935581.html
https://www.cnblogs.com/yichengbo/p/3719387.html
https://www.cnblogs.com/yichengbo/p/3719164.html
https://www.w3school.com.cn/js/pro_js_inheritance_implementing.asp
出于安全原因,本地类和宿主类不能作为基类,这样可以防止公用访问编译过的浏览器级的代码,因为这些代码可以被用于恶意攻击。
有时,你可能想创建一个不能直接使用的基类,它只是用于给子类提供通用的函数。在这种情况下,基类被看作抽象类。
创建的子类将继承超类的所有属性和方法,包括构造函数及方法的实现。
ECMAScript 实现继承的方式不止一种;是因为 JavaScript 中的继承机制并不是明确规定的,而是通过模仿实现的。这意味着所有的继承细节并非完全由解释程序处理。作为开发者,你有权决定最适用的继承方式。
继承方式:
1》对象冒充:使A类的构造方法成为B类的方法,然后在B类的构造方法中调用此方法。
构想原始的 ECMAScript 时,根本没打算设计对象冒充(object masquerading)。它是在开发者开始理解函数的工作方式,尤其是如何在函数环境中使用 this 关键字后才发展出来。
原理:构造函数使用 this 关键字给所有属性和方法赋值(即采用类声明的构造函数方式)。因为构造函数只是一个函数,所以可使 ClassA 构造函数成为 ClassB 的方法,然后调用它。ClassB 就会收到 ClassA 的构造函数中定义的属性和方法;这个原理是把 ClassA 作为常规函数来建立继承机制,而不是作为构造函数。在代码中,为 ClassA 赋予了方法 newMethod(请记住,函数名只是指向它的指针)。然后调用该方法,传递给它的是 ClassB 构造函数的参数 sColor。最后一行代码删除了对 ClassA 的引用,这样以后就不能再调用它;所有新属性和新方法都必须在删除了新方法的代码行后定义。否则,可能会覆盖超类的相关属性和方法(我未删除,暂未发现覆盖的问题,可能在特定情况下会出问题)
1.1》冒充对象-直接法
{//冒充对象
function classA(sColor) {
this.color = sColor;
this.sayColor = function () {
console.log(this.color);
}
}
function classB(sColor,name) {
this.newMethod = classA;
this.newMethod(sColor);
delete this.newMethod;
this.BMethod = function () {
console.log('B类新加的方法');
}
this.Bname = name;
}
var a = new classA('blue');
var b = new classB('red','小龙');
a.sayColor();//blue
// a.BMethod(); //Uncaught TypeError: a.BMethod is not a function
b.sayColor();//red
b.BMethod();//B类新加的方法
console.log(a.color,a.Bname,b.color,b.Bname);//blue,undefined,red,小龙
}
冒充对象可以实现多重继承
function ClassZ() {
this.newMethod = ClassX;
this.newMethod();
delete this.newMethod;
this.newMethod = ClassY;
this.newMethod();
delete this.newMethod;
}
这里存在一个弊端,如果存在两个类 ClassX 和 ClassY 具有同名的属性或方法,ClassY 具有高优先级。因为它从后面的类继承。除这点小问题之外,用对象冒充实现多重继承机制轻而易举
call()方法 function sayColor(sPrefix,sSuffix) {
alert(sPrefix + this.color + sSuffix);
};
var obj = new Object();
obj.color = "blue";
sayColor.call(obj, "The color is ", "a very nice color indeed.");
1.2》冒充对象-call()方法:与对象冒充方法相似;参数一:this对象;其他参数都直接传递给函数自身。
要与继承机制的对象冒充方法一起使用该方法,只需将前三行的赋值、调用和删除代码替换即可:
function ClassB(sColor, sName) {
//this.newMethod = ClassA;
//this.newMethod(color);
//delete this.newMethod;
ClassA.call(this, sColor);
this.name = sName;
this.sayName = function () {
alert(this.name);
};
}
1.3》冒充对象-apply()方法:与call()方法相似;参数一:this对象;参数二:要传递给函数的参数的数组;
注:webstorm(MAC)格式化快捷键:option + cmd + L
2》原型链:(prototype-chaining)//原型链不经继承以原型方式创建的属性和方法,也继承构造函数中创建的属性和方法
继承这种形式在 ECMAScript 中原本是用于原型链的。上一章介绍了定义类的原型方式。原型链扩展了这种方式,以一种有趣的方式实现继承机制。
在上一章学过,prototype 对象是个模板,要实例化的对象都以这个模板为基础。总而言之,prototype 对象的任何属性和方法都被传递给那个类的所有实例。原型链利用这种功能来实现继承机制。
function ClassA() {
this.onlyAPro = 'aOne';
this.onlyAFunc = function () {
console.log(this,'这是ClassA的only方法',this.onlyAPro);
}
}
ClassA.prototype.name = '小明';
ClassA.prototype.age = 12;
ClassA.prototype.aMethod = function () {
console.log(this.name,this.age);
}
function ClassB() {
this.onlyBPro = 'bOne';
this.onlyBFunc = function () {
console.log(this,'这是ClassB的only方法',this.onlyBPro);
}
}
ClassB.prototype = new ClassA();
ClassB.prototype.address = '中国';
ClassB.prototype.name = '晓梅';
ClassB.prototype.bMethod = function () {
console.log(this.name,this.age,this.address);
}
var a = new ClassA();
a.aMethod();
a.onlyAFunc();
// a.bMethod();//Uncaught TypeError: a.bMethod is not a function
var b = new ClassB();
b.age = 23;
b.aMethod();
b.bMethod();
b.onlyBFunc();
b.onlyAFunc();
//原型链不经继承以原型方式创建的属性和方法,也继承构造函数中创建的属性和方法
//注意:在原型链中,instanceof 运算符的运行方式也很独特。对 ClassB 的所有实例,instanceof 为 ClassA 和 ClassB 都返回 true
console.log(a instanceof ClassA);
console.log(b instanceof ClassB);
原型方式的神奇之处在于ClassB.prototype = new ClassA();。这里,把 ClassB 的 prototype 属性设置成 ClassA 的实例。这很有意思,因为想要 ClassA 的所有属性和方法,但又不想逐个将它们 ClassB 的 prototype 属性。这是最好方法。
注意:调用 ClassA 的构造函数,没有给它传递参数。这在原型链中是标准做法。要确保构造函数没有任何参数。
与对象冒充相似,子类的所有属性和方法都必须出现在 prototype 属性被赋值后,因为在它之前赋值的所有方法都会被删除。因为 prototype 属性被替换成了新对象,添加了新方法的原始对象将被销毁。
在原型链中,instanceof 运算符的运行方式也很独特。对 ClassB 的所有实例,instanceof 为 ClassA 和 ClassB 都返回 true
console.log(a instanceof ClassA);
console.log(b instanceof ClassB);
在 ECMAScript 的弱类型世界中,这是极其有用的工具,不过使用对象冒充时不能使用它。
原型链的弊端是不支持多重继承。记住,原型链会用另一类型的对象重写类的 prototype 属性。
3》混合方式:创建类的最好方式是用构造函数定义属性,用原型定义方法。这种方式同样适用于继承机制,用对象冒充继承构造函数的属性,用原型链继承 prototype 对象的方法
function ClassA(name) {
this.name = name;
}
ClassA.prototype.tellStory = function () {
console.log('听',this.age,'岁的',this.name,'讲ClassA的故事');
}
function ClassB(name,age) {
ClassA.call(this,name);
this.age = age;
}
ClassB.prototype = new ClassA();
var a = new ClassA('小龙');
var b = new ClassB('小丽',13);
a.tellStory();
b.tellStory();
console.log(a instanceof ClassA);//true
console.log(b instanceof ClassB);//true
由于这种混合方式使用了原型链,所以 instanceof 运算符仍能正确运行
URL URI:
URL 的常见定义格式为:scheme://host[:port#]/path/.../[;url-params][?query-string][#anchor]
URL:统一资源定位符
URI:统一资源标识符
URI 属于父类,而 URL 属于 URI 的子类。URL 是 URI 的一个子集。
二者的区别在于,URI 表示请求服务器的路径,定义这么一个资源。而 URL 同时说明要如何访问这个资源(http://)
https://www.cnblogs.com/haore147/p/5507662.html
14、对象-定义类或对象的方式:
1》工厂方式:
每个对象都有自己的 showColor() 版本。而事实上,每个对象都共享同一个函数。
有些开发者在工厂函数外定义对象的方法,然后通过属性指向该方法,从而避免这个问题:
function showColor() {
alert(this.color);
}
function createCar(sColor,iDoors,iMpg) {
var oTempCar = new Object;
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = showColor;
return oTempCar;
}
var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);
oCar1.showColor(); //输出 "red"
oCar2.showColor(); //输出 "blue"
2》构造函数方式:
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.showColor = function() {
alert(this.color);
};
}
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);
就像工厂函数,构造函数会重复生成函数,为每个对象都创建独立的函数版本。不过,与工厂函数相似,也可以用外部函数重写构造函数,同样地,这么做语义上无任何意义。这正是下面要讲的原型方式的优势所在
3》原型方式:
function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function() {
alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.drivers.push("Bill");
alert(oCar1.drivers); //输出 "Mike,John,Bill"
alert(oCar2.drivers); //输出 "Mike,John,Bill"
问题:
1、这个构造函数没有参数。使用原型方式,不能通过给构造函数传递参数来初始化属性的值
2、函数共享不会造成问题,但对象却很少被多个实例共享,是引用值,Car 的两个实例都指向同一个数组。这意味着给 oCar1.drivers 添加值 "Bill",在 oCar2.drivers 中也能看到。输出这两个指针中的任何一个,结果都是显示字符串 "Mike,John,Bill"。
4》混合的构造函数/原型方式:最优解
联合使用构造函数和原型方式,就可像用其他程序设计语言一样创建对象。这种概念非常简单,即用构造函数定义对象的所有非函数属性,用原型方式定义对象的函数属性(方法)。结果是,所有函数都只创建一次,而每个对象都具有自己的对象属性实例
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike","John");
}
Car.prototype.showColor = function() {
alert(this.color);
};
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);
oCar1.drivers.push("Bill");
alert(oCar1.drivers); //输出 "Mike,John,Bill"
alert(oCar2.drivers); //输出 "Mike,John"
5》动态原型方法:次优解
动态原型方法的基本想法与混合的构造函数/原型方式相同,即在构造函数内定义非函数属性,而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike","John");
if (typeof Car._initialized == "undefined") {
Car.prototype.showColor = function() {
alert(this.color);
};
Car._initialized = true;
}
}
6》混合工厂方式:
这种方式通常是在不能应用前一种方式时的变通方法。它的目的是创建假构造函数,只返回另一种对象的新实例。
这段代码看起来与工厂函数非常相似
function Car() {
var oTempCar = new Object;
oTempCar.color = "blue";
oTempCar.doors = 4;
oTempCar.mpg = 25;
oTempCar.showColor = function() {
alert(this.color);
};
return oTempCar;
}
var car = new Car();
结论:使用最广泛的是混合的构造函数/原型方式。此外,动态原始方法也很流行,在功能上与构造函数/原型方式等价。可以采用这两种方式中的任何一种。
15、对象-对象作用域:
1》公用、私有、受保护作用域
ECMAScript只有公用作用域;ECMAScript 中的所有对象的所有属性和方法都是公用的;
建议性解决方法:有效的属性作用域模式,解决了ECMAScript这种问题;
由于缺少私有作用域,开发者确定了一个规约,说明哪些属性和方法应该被看做私有的。这种规约规定在属性前后加下划线:obj._color_ = "blue";
注意:下划线并不改变属性是公用属性的事实,它只是告诉其他开发者,应该把该属性看作私有的。
2》静态作用域:ECMAScript 没有静态作用域
严格来说,ECMAScript 并没有静态作用域。不过,它可以给构造函数提供属性和方法。构造函数只是函数。函数是对象,对象可以有属性和方法
function sayHello() {
alert("hello");
}
sayHello.alternate = function() {
alert("hi");
}
sayHello(); //输出 "hello"
sayHello.alternate(); //输出 "hi"
这里,方法 alternate() 实际上是函数 sayHello 的方法。可以像调用常规函数一样调用 sayHello() 输出 "hello",也可以调用 sayHello.alternate() 输出 "hi"。即使如此,alternate() 也是 sayHello() 公用作用域中的方法,而不是静态方法。
3》关键字this:在对象的方法中。关键字 this 总是指向调用该方法的对象
var oCar = new Object;
oCar.color = "red";
oCar.showColor = function() {
alert(this.color);//等价于alert(oCar.color);
};
oCar.showColor(); //输出 "red"
//this 等于 oCar。
使用this原因:因为在实例化对象时,总是不能确定开发者会使用什么样的变量名。使用 this,即可在任何多个地方重用同一个函数。
如果不用对象或 this 关键字引用变量,ECMAScript 就会把它看作局部变量或全局变量。然后该函数将查找名为 color 的局部或全局变量,但是不会找到。结果如何呢?该函数将在警告中显示 "null"
function showColor() {
alert(color);
};
16、对象-修改对象:
1》创建新方法:
Number.prototype.toHexString = function() {
return this.toString(16);
};
var iNum = 15;
alert(iNum.toHexString()); //输出 "F"
2》重命名已有方法:
我们还可以为已有的方法命名更易懂的名称。例如,可以给 Array 类添加两个方法 enqueue() 和 dequeue(),只让它们反复调用已有的 push() 和 shift() 方法即可:
Array.prototype.enqueue = function(vItem) {
this.push(vItem);
};
Array.prototype.dequeue = function() {
return this.shift();
};
3》添加与已有方法无关的方法:假设要判断某个项在数组中的位置,没有本地方法可以做这种事情。我们可以轻松地创建下面的方法:
Array.prototype.indexOf = function (vItem) {
for (var i=0; i
if (vItem == this[i]) {
return i;
}
}
return -1;
}
var aColors = new Array("red","green","blue");
alert(aColors.indexOf("green")); //输出 "1"
4》为本地对象添加新方法:如果想给 ECMAScript 中每个本地对象添加新方法,必须在 Object 对象的 prototype 属性上定义它;所有本地对象都继承了 Object 对象,所以对 Object 对象做任何改变,都会反应在所有本地对象上。例如,如果想添加一个用警告输出对象的当前值的方法,可以采用下面的代码:
Object.prototype.showValue = function () {
alert(this.valueOf());
};
var str = "hello";
var iNum = 25;
str.showValue(); //输出 "hello"
iNum.showValue(); //输出 "25"
5》重定义已有方法:
Function.prototype.toString = function() {
return "Function code hidden";
}
function sayHi() {
alert("hi");
}
alert(sayHi.toString()); //输出 "Function code hidden"
toString() 指向的原始函数怎么了呢?它将被无用存储单元回收程序回收,因为它被完全废弃了。没有能够恢复原始函数的方法,所以在覆盖原始方法前,比较安全的做法是存储它的指针,以便以后的使用。有时你甚至可能在新方法中调用原始方法:
Function.prototype.originalToString = Function.prototype.toString;
Function.prototype.toString = function() {
if (this.originalToString().length > 100) {
return "Function too long to display.";
} else {
return this.originalToString();
}
};
6》极晚绑定:从技术上讲,根本不存在极晚绑定。本书采用该术语描述 ECMAScript 中的一种现象,即能够在对象实例化后再定义它的方法。
var o = new Object();
Object.prototype.sayHi = function () {
alert("hi");
};
o.sayHi();
在大多数程序设计语言中,必须在实例化对象之前定义对象的方法。这里,方法 sayHi() 是在创建 Object 类的一个实例之后来添加进来的。在传统语言中不仅没听说过这种操作,也没听说过该方法还会自动赋予 Object 对象的实例并能立即使用(接下来的一行)。
注意:不建议使用极晚绑定方法,因为很难对其跟踪和记录。不过,还是应该了解这种可能。
15、js事件:
16、js字符串:
\转义符:
\' '
\" "
\\ \
\b 退格
\f 换页
\n 换行
\r 回车
\t 水平制表符
\v 垂直制表符
长代码行换行:为了最佳可读性, 程序员们通常会避免每行代码超过 80 个字符串。如果某条 JavaScript 语句不适合一整行,那么最佳换行位置是某个运算符之后;
也可以在字符串中换行,通过一个反斜杠即可:document.getElementById("demo").innerHTML = "Hello \
Kitty!";
\ 方法并不是 ECMAScript (JavaScript) 标准。
某些浏览器也不允许 \ 字符之后的空格。
对长字符串换行的最安全做法(但是有点慢)是使用字符串加法:
document.getElementById("demo").innerHTML = "Hello" +
"Kitty!";
字符串可以是对象 new创建:var y = new String("Bill");
字面方式创建:var firstName = "Bill"
注:请不要把字符串创建为对象。它会拖慢执行速度
var x = "Bill";
var y = new String("Bill");
// (x === y) 为 false,因为 x 和 y 的类型不同(字符串与对象)
var x = new String("Bill");
var y = new String("Bill");
// (x == y) 为 false,因为 x 和 y 是不同的对象
17、js字符串方法
//1、查找字符串
//indexOf()返回字符串中指定文本首次出现的索引;如果未找到文本, indexOf() 和 lastIndexOf() 均返回 -1。
//作为检索起始位置的第二个参数
var str = "The full name of China is the People's Republic of China.";
var pos = str.indexOf('china')
var pos1 = str.indexOf('China')
var pos2 = str.indexOf('China',18);
var pos2 = str.indexOf('China',3);
console.log(pos,pos1,pos2);
//lastIndexOf() 法返回指定文本在字符串中最后一次出现的索引;如果未找到文本, indexOf() 和 lastIndexOf() 均返回 -1。
//lastIndexOf() 方法向后进行检索(从尾到头),这意味着:假如第二个参数是 50,则从位置 50 开始检索,直到字符串的起点。
var lain = str.lastIndexOf('China');
var lain1 = str.lastIndexOf('China',50);
var lain2 = str.lastIndexOf('China',52);
console.log(lain,lain1,lain2);
//search()方法搜索特定值的字符串,并返回匹配的位置:可与正则联合使用
var se = str.search('locate');
var se1 = str.search('China');
var se2 = str.search(/china/i);
console.log(se,se1,se2);
//2、提取部分字符串
/**
* slice(start,end) [)
* 1:如果某个参数为负,则从字符串的结尾开始计数
* 2:如果省略第二个参数,则该方法将裁剪字符串的剩余部分
* index = str.length + 负数
* substring(start,end) [)
* 1:substring() 类似于 slice()。
* 2:不同之处在于 substring() 无法接受负的索引
* 3:如果省略第二个参数,则该 substring() 将裁剪字符串的剩余部分。
* substr(start,end) [)
* 1:substr() 类似于 slice()
* 2:不同之处在于第二个参数规定被提取部分的长度
* 3:如果省略第二个参数,则该 substr() 将裁剪字符串的剩余部分
* 4:第一个参数可以为负,第二个则不能为负;如果首个参数为负,则从字符串的结尾计算位置
* */
//slice()
var str = "Apple, Banana, Mango";
var res = str.slice(7,13);
var res1 = str.slice(-13,-7);//str.slice(-13+str.length,-7+str.length)
var res2 = str.slice(7);
var res3 = str.slice(-13);
console.log(str.length,res,res1,res2,res3);
// Banana Banana Banana, Mango Banana, Mango
//substring()
var str = "Apple, Banana, Mango";
var subS = str.substring(7,13);
var subS1 = str.substring(7);
console.log(subS,subS1);
//substr()
var str = "Apple, Banana, Mango";
var res = str.substr(7,6);
var res1 = str.substr(7);
var res2 = str.substr(-5);
console.log(res,res1,res2);
//3、替换字符串内容replace()
/**
* replace() 方法不会改变调用它的字符串。它返回的是新字符串。
* 默认地,replace() 只替换首个匹配
* 默认地,replace() 对大小写敏感
* 与正则联合使用
*
* */
str = "Please visit Microsoft!";
var restr = str.replace('Microsoft','mama');
console.log(str,restr);
//4、大小写转换
//大写
var text1 = "Hello World!";
var text2 = text1.toUpperCase();
//小写
var text3 = text1.toLowerCase();
console.log(text1,text2,text3);
//5、concat() 连接两个或多个字符串;所有字符串方法都会返回新字符串。它们不会修改原始字符串。
// 正式地说:字符串是不可变的:字符串不能更改,只能替换
var tex1 = 'hello';
var tex2 = 'world';
var tex3 = tex1.concat('',tex2);
var tex4 = tex1.concat('-',tex2);
var tex5 = tex1.concat('aa','bb','cc');
console.log(tex3,tex4,tex5);
//6、trim() 方法删除字符串两端的空白符
var str = ' hello world! ';
var strr = str.trim();
console.log(str,strr);
//正则去两端的空白
var str = " Hello World! ";
var strrr = str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
console.log(strrr);
//7、提取字符串字符
/**
* charAt(position) 方法返回字符串中指定下标(位置)的字符串
* charCodeAt(position) 方法返回字符串中指定索引的字符 unicode 编码
* */
//charAt(position)
var str = "HELLO WORLD"
var str1 = str.charAt(0);
//charCodeAt(position)
var str2 = str.charCodeAt(0);
console.log(str1,str2);
//8、属性访问
/**
使用属性访问有点不太靠谱:
不适用 Internet Explorer 7 或更早的版本
它让字符串看起来像是数组(其实并不是)
如果找不到字符,[ ] 返回 undefined,而 charAt() 返回空字符串。
它是只读的。str[0] = "A" 不会产生错误(但也不会工作!)
* */
var str = "HELLO WORLD";
var s = str[0];
console.log(s);//H
//不靠谱
str[0] = 's';
console.log(str[0]);//依旧是H
//9、字符串转换为数组 split()
/**
* 如果省略分隔符,被返回的数组将包含 index [0] 中的整个字符串
* 如果分隔符是 "",被返回的数组将是间隔单个字符的数组
* */
var txt = 'a,b,c,d,e';
var t1 = txt.split(',');
var t2 = txt.split('');
var t3 = txt.split('|');
console.log(t1,t2,t3);
// ["a", "b", "c", "d", "e"] ["a", ",", "b", ",", "c", ",", "d", ",", "e"] ["a,b,c,d,e"]
18、js数字
JavaScript 只有一种数值类型;书写数值时带不带小数点均可。
//1、书写 只有一种数值类型 JavaScript 数值既可以带小数点,也可以不带
var x = 3.14;
var y = 3;
//2、科学计数
var x = 123e5;
var y = 123e-5;
console.log(x,y);
//3、js数值始终是64位的浮点数
/**
* 与许多其他编程语言不同,JavaScript 不会定义不同类型的数,比如整数、短的、长的、浮点的等等;
* JavaScript 数值始终以双精度浮点数来存储,根据国际 IEEE 754 标准。
* 此格式用 64 位存储数值,其中 0 到 51 存储数字(片段),52 到 62 存储指数,63 位存储符号:
* */
//4、精度:
// 整数(不使用指数或科学计数法)会被精确到15位
var x = 999999999999999;//15 999999999999999
var y = 9999999999999999;//16 10000000000000000 17
console.log(x,y);
//999999999999999 10000000000000000
// 小数 小数的最大数是 17 位,但是浮点的算数并不总是 100% 精准
var x = 0.2 + 0.1;
console.log(x);
//0.30000000000000004 //17
var x = 2e-1 + 1e-1;
console.log(x);
//乘法解决以上问题
var x = (0.2 * 10 + 0.1 * 10)/10;
console.log(x);
//5、数字和字符相加
// js加法和级联(concatenation)都使用 + 运算符。
// 在所有数字运算中,js会尝试将字符串转化为数字 / * -
//6、数字字符串
var x = "100";
var y = "10";
var z = x / y
var m = x - y;
var n = x * y;
console.log(z,m,n,typeof z,typeof m,typeof n);
//7、NaN 非数值
// NaN 属于 JavaScript 保留词,指示某个数不是合法数。
// NaN 是数,typeof NaN 返回 number:
var x = 100 / "Apple";
isNaN(x);
console.log(x,isNaN(x));
//NaN true
//数学运算中使用了 NaN,则结果也将是 NaN
var x = NaN;
var y = 5;
var z = x + y; // z 将是 NaN
console.log(z);
//级联运算中使用了 NaN,结果是字符串
var x = NaN;
var y = "5";
var z = x + y; // z 将是 NaN5
console.log(z);
//8、Infinity:Infinity (或 -Infinity)是 JavaScript 在计算数时超出最大可能数范围时返回的值
// 除以 0(零)也会生成 Infinity
var x = 2 / 0; // x 将是 Infinity
var y = -2 / 0; // y 将是 -Infinity
console.log(x,y,typeof Infinity,typeof -Infinity);
//9、进制
/**
* 绝不要用前导零写数字(比如 07),一些 JavaScript 版本会把带有前导零的数解释为八进制
*默认地,Javascript 把数显示为十进制小数。
*但是您能够使用 toString() 方法把数输出为十六进制、八进制或二进制。
* */
var num = 128;
var a = num.toString(16);
var b = num.toString(8);
var c = num.toString(2);
console.log(a,b,c);
//10、数值可以是对象
/**
* 请不要创建数值对象。这样会拖慢执行速度。
new 关键词使代码复杂化,并产生某些无法预料的结果;
当使用 == 相等运算符时,相等的数看上去相等;
对象无法进行对比
* */
var x = 123;
var y = new Number(123);
console.log(typeof x,typeof y)
// number object
console.log(x == y,x === y);
//true false
//对象无法进行对比
var ff = new Number(500);
var gg = new Number(500);
console.log(ff == gg,ff === gg);
//false false
19、js Let
js块作用域:
1》通过var声明的变量没有块作用域,即块{}内声明的变量可以在块外进行访问。
{
var x = 10;
}
// 此处可以使用 x
ES2015之前,js没有块作用域。ES2015 引入了两个重要的 JavaScript 新关键词:let 和 const
可以使用let关键词声明拥有块作用域的变量。
2》let在块{}内声明的变量无法在块外访问。
{
let x = 10;
}
// 此处不可以使用 x
3》重新声明变量:使用var关键字重新声明变量会带来问题。在块中声明变量也将重新声明块外变量。使用 let 关键字重新声明变量可以解决这个问题。
var x = 10;
// 此处 x 为 10
{
var x = 6;
// 此处 x 为 6
}
// 此处 x 为 6
用 let 关键字重新声明变量可以解决这个问题,在块中重新声明变量不会重新声明块外的变量。
var x = 10;
// 此处 x 为 10
{
let x = 6;
// 此处 x 为 6
}
// 此处 x 为 10
4》循环作用域:
4.1》在循环中使用var:
var i = 7;
for (var i = 0; i < 10; i++) {
// 一些语句
}
// 此处,i 为 10
此循环中使用var重新声明了循环外的变量i
4.2》在循环中使用let:
let i = 7;
for (let i = 0; i < 10; i++) {
// 一些语句
}
// 此处 i 为 7
此循环中使用let并没有重新声明循环外的变量;如果在循环中用let声明了变量i,那么只有在循环内i才是可见的。
5》函数作用域:
在函数内声明变量时,let和var很相似。都有函数作用域:
function myFunction() {
var carName = "porsche"; // 函数作用域
}
function myFunction() {
let carName = "porsche"; // 函数作用域
}
6》全局作用域:在块外声明,var和let也很相似,都有全局作用域;
var x = 10; // 全局作用域
let y = 6; // 全局作用域
7》HTML中全局变量:
使用js情况下,全局作用域是js环境;
在HTML中,全局作用域是window;
通过var关键词定义的全局变量属于window;
通过let关键词定义的全局变量不属于window;
8》重新声明:
8.1》允许在程序的任何位置使用 var 重新声明 JavaScript 变量:
var x = 10;
// 现在,x 为 10
var x = 6;
// 现在,x 为 6
8.2》在相同的作用域,或在相同的块中,通过 let 重新声明一个 var 变量是不允许的
var x = 10; // 允许
let x = 6; // 不允许
{
var x = 10; // 允许
let x = 6; // 不允许
}
8.3》在相同的作用域,或在相同的块中,通过 let 重新声明一个 let 变量是不允许的
let x = 10; // 允许
let x = 6; // 不允许
{
let x = 10; // 允许
let x = 6; // 不允许
}
8.4》在相同的作用域,或在相同的块中,通过 var 重新声明一个 let 变量是不允许的
let x = 10; // 允许
var x = 6; // 不允许
{
let x = 10; // 允许
var x = 6; // 不允许
}
8.5》在不同的作用域或块中,通过 let 重新声明变量是允许的:
let x = 6; // 允许
{
let x = 7; // 允许
}
{
let x = 8; // 允许
}
9》提升:
通过 var 声明的变量会提升到顶端;可以在声明变量之前就使用它
通过 let 定义的变量不会被提升到顶端;在声明 let 变量之前就使用它会导致 ReferenceError,变量从块的开头一直处于“暂时死区”,直到声明为止。
20、js数组:(家里电脑 WebstormProjects/untitled/)
//1、创建数组
//字面量方法:
//存同种类型元素
var cars = ['ss','d','D','true'];
console.log(cars);
//存不同类型的元素
var array1 = ['s',true,12,'dd'];
console.log(array1);
//new创建数组:存不同类型的元素
var newArray = new Array('trr','收到',34);
console.log(newArray);
//2、访问数组元素
var a1 = newArray[0];
console.log(a1);
//3、元素赋值
newArray[0] = '匀速';
console.log(newArray);
//4、访问完整数组
console.log(newArray);
//5、数组是对象
console.log(typeof array1,typeof newArray);
//6、数组元素可以是不同类型的变量;
var func = new Function('boy','girl','console.log(boy,girl);console.log(\'男孩和女孩\',boy,girl);')
var objecrtArray = new Array(Date.now(),func,cars);
console.log(objecrtArray);
//7、数组属性和方法
var x = objecrtArray.length;
var y = objecrtArray.sort();
console.log(x,y)
//8、遍历数组
//8.1 for循环遍历数组
for (i = 0;i < objecrtArray.length;i++){
console.log(objecrtArray[i])
}
//8.2 forEach(func) 为每个数组元素调用函数
var text = '0';
function myFunction(value) {
text += value;
}
objecrtArray.forEach(myFunction);
console.log(text);
//8.3添加数组元素
// push()
console.log(objecrtArray);
objecrtArray.push('水果');
console.log(objecrtArray);
//index
objecrtArray[objecrtArray.length] = '拧开干妈看穿一切';
console.log(objecrtArray);
//8.3.1添加最高索引的元素可在数组中创建未定义的'洞'
objecrtArray[objecrtArray.length + 1] = '未定义的洞';
console.log(objecrtArray);
//8.4 关联数组:很多编程元素支持命名索引的数组;具有命名索引的数组别称为关联数组
//js不支持命名索引的数组;js只能使用数字索引
//如果在js中使用了命名索引数组,则会将此数组重新定义为标准对象,则所有数组的方法和属性将产生非正确结果(亲测,js索引数组没这些毛病)
var person = [];
person[0] = '人1';
person[1] = '人2';
console.log(person,person instanceof Array,person.length);
person['第三个人'] = '三人成虎';
console.log(person,person instanceof Array,person.length);
//8.5 识别数组 isArray()
var dd = Array.isArray(objecrtArray);
console.log(dd);
21、数组方法:
var array = ['a','b','c'];
//1、合成用逗号分割的字符串
var a1 = array.toString();
console.log(a1);
//2、合成用指定字符分割的字符串
var a2 = array.join();
console.log(a2);
var a3 = array.join('*');
console.log(a3);
var a4 = array.join('');
console.log(a4);
//3、pop() 删除最后一个元素,并返回最后一个元素
var a5 = array.pop()
console.log('a5:'+a5);
//4、push()返回数组长度
var a6 = array.push('push');
console.log('a6:'+a6);
//5、shift() 删除第一个元素,数组元素索引整体变小;并返回删除的元素
var a7 = array.shift();
console.log('a7:'+a7);
//6、unshift() 向数组开头添加元素,返回数组长度
var a8 = array.unshift('unshift');
console.log('a8:'+a8,array);
//7、更改元素
array[0] = '更改第一个元素';
//8、删除元素:delete会产生数组空洞,一般不用delete删除,而用pop或splice
delete array[2];
console.log('删除第三个元素后:',array);
//9、拼接数组splice() 返回新的数组(只返回被删除的元素组成的数组,不包含新添加的元素);原数组会被改变
var a9 = array.splice(1,1,'splice1','splice2');//删除并添加元素
var ad = ['1','2','3','4','5','6','7'];
var ad1 = ad.splice(1,2,'收到','发');
console.log('a9:'+a9,'ad1:'+ad1,ad);
var a10 = array.splice(1,3);//删除元素
console.log('a10:'+a10);
//10、合并数组concat() 返回一个新数组,原数组不变
var array1 = ['concat1','concat2','concat3'];
var array2 = ['conc1','conc2','conc3'];
var a11 = array.concat(array1,array2);
console.log('a11:'+a11);
//11、剪裁数组 slice() 返回剪裁后的数组;原数组不变
console.log("array:"+array);
var a12 = a11.slice(1,3);
console.log('a12:'+a12,a11);
var a13 = a11.slice(2);//从索引2开始剪裁剩下的数组
console.log('a13:'+a13,a11);
//12、自动toString()
document.getElementsByClassName('hh')[0].innerHTML = array;
document.getElementsByClassName('hhh')[0].innerHTML = array.toString();
22、数组排序:
var fruits = ["Banana", "Orange", "Apple", "Mango"];
console.log(fruits);
//1、排序sort()
fruits.sort();
console.log(fruits);
//2、翻转数组
fruits.reverse();
console.log(fruits);
//3、数字排序
var numArray = [21,13,1,3,6,12];
console.log(numArray);
numArray.sort();
console.log(numArray);
//升序
numArray.sort(function (a, b) {
return a - b;
});
console.log(numArray);
//降序
numArray.sort(function (a, b) {
return b - a;
})
console.log(numArray);
//4、查找数组最大、小值
//4.1、排序后查找,效率极低
//4.2、Math.max;Math.min
var max = Math.max.apply(null,numArray);
var min = Math.min.apply(null,numArray);
console.log(max,min);
//4.3、自制方法
//最大值 此函数遍历数组,用找到的最高值与每个值进行比较
function myArrayMax(arr) {
var len = arr.length
var max = -Infinity;
while (len--) {
if (arr[len] > max) {
max = arr[len];
}
}
return max;
}
var maxx = myArrayMax(numArray);
console.log('自制函数max:',maxx);
//最小值 此函数遍历数组,用找到的最低值与每个值进行比较
function myArrayMin(arr) {
var len = arr.length
var min = Infinity;
while (len--) {
if (arr[len] < min) {
min = arr[len];
}
}
return min;
}
var minm = myArrayMin(numArray);
console.log('自制函数min:',minm);
//5、排序对象数组
var cars = [{type:'Volovw',year:2015},{type: 'Saab',year: 2001},{type:'BMW',year:2010}];
//数字排序:根据year
// cars.sort(function (a,b) {
// return a.year - b.year;
// })
cars.sort(function(a, b){return a.year - b.year});
console.log(cars);
/**
* 0: {type: "Saab", year: 2001}
* 1: {type: "BMW", year: 2010}
* 2: {type: "Volovw", year: 2015}
* */
//文字排序:根据type
cars.sort(function (a, b) {
var x = a.type.toLowerCase();
var y = b.type.toLowerCase();
if (x < y){return -1;}
if (x > y){return 1;}
return 0;
});
console.log(cars);
/**
* 0: {type: "BMW", year: 2010}
* 1: {type: "Saab", year: 2001}
* 2: {type: "Volovw", year: 2015}
* */
23、数组迭代:
//1、forEach() 方法为每个数组元素调用一次函数(回调函数);不产生新数组
var number = [45,4,9,16,25];
console.log(number);
var newArray = [];
number.forEach(function (value, index, array) {
newArray[index] = value + 2;
});
console.log(number,newArray);
//2、map()产生新数组
/**
* map() 方法通过对每个数组元素执行函数来创建新数组。
map() 方法不会对没有值的数组元素执行函数。
map() 方法不会更改原始数组。
* */
var newN = number.map(function (value, index, array) {
return value += 3;
});
console.log(number,newN);
//3、filter() 方法创建一个包含通过测试的数组元素的新数组
var over18 = number.filter(function (value,index,array) {
return value > 18
});
console.log('over18:',over18);
//4、reduce() 返回一个值
/**
* reduce() 方法在每个数组元素上运行函数,以生成(减少它)单个值。
reduce() 方法在数组中从左到右工作。另请参见 reduceRight()。
reduce() 方法不会减少原始数组
* */
var sum = number.reduce(function (total,value,index,array) {
console.log('total:'+total);
return total + value;
});
console.log(sum);
//5、reduceRight() 与reduce()啥区别
/**
* reduceRight() 方法在每个数组元素上运行函数,以生成(减少它)单个值。
reduceRight() 方法在数组中从左到右工作。另请参见 reduce()。
reduceRight() 方法不会减少原始数组
* */
var sumRight = number.reduceRight(function (total,value,index,array) {
return total + value;
});
console.log('sumRight:'+sumRight);
//6、every() 查看是否每个元素都满足条件;返回boolean值
var every = number.every(function (value, index, array) {
return value > 18;
});
console.log(every);
//7、some() 查看是否有元素满足条件;返回boolean值
var some = number.some(function (value, index, array) {
return value > 18;
});
console.log(some);
//8、indexOf() 方法在数组中搜索元素值并返回其位置。
var fruits = ["Apple", "Orange", "Apple", "Mango","Apple"];
var a = fruits.indexOf("Apple");
//9、lastIndexOf() array.lastIndexOf(item, start) start可选。从哪里开始搜索。负值将从结尾开始的给定位置开始,并搜索到开头
var b = fruits.lastIndexOf("Apple");
var c = fruits.lastIndexOf("Apple",1);//????不太好使呢,这个方法
console.log(a,b,c);
//10、find() 方法返回通过测试函数的第一个数组元素的值
var finds = number.find(function (value,index,array) {
return value > 18;
});
console.log('find:',finds);
//11、findIndex() 方法返回通过测试函数的第一个数组元素的索引
var findindex = number.findIndex(function (value, index, array) {
return value < 18;
});
console.log(findindex);
24、日期
var d = new Date();
console.log(d);
/**
创建 Date 对象
Date 对象由新的 Date() 构造函数创建。
有 4 种方法创建新的日期对象:
new Date()
new Date(year, month, day, hours, minutes, seconds, milliseconds)
new Date(milliseconds)
new Date(date string)*
* */
var d1 = new Date(2018,11,24,10,33,30,0);
var d2 = new Date(2018,11,24,10,33,30);
var d3 = new Date(2018,11,24,10,33);
var d4 = new Date(2018,11,24,10);
var d5 = new Date(2018,11,24);
var d6 = new Date(2018,11);
var d7 = new Date(2018);//不能神略月份,如果只提供一个参数,则将其视为毫秒
console.log(d1,d2,d3,d4,d5,d6,d7);
//上世纪:一位和两位数年份将被解释为 19xx 年
var d8 = new Date(99,11,24);
var d9 = new Date(9,11,24);
console.log(d8,d9);
//日期字符串 new Date(dateString) 从日期字符串创建一个新的日期对象
var d10 = new Date("October 13, 2014 11:13:00");
console.log(d10);
// new Date(milliseconds) 创建一个零时加毫秒的新日期对象
var d11 = new Date(0);
var d12 = new Date(100000000000);//1970年 1 月 1 日加上100 000 000 000毫秒,大约是 1973 年 3 月 3 日
var d13 = new Date(-100000000000);//1970 年 1 月 1 日减去 100 000 000 000 毫秒大约是 1966 年 10 月 31 日
console.log(d11,d12,d13);
//在 HTML 中显示日期对象时,会使用 toString() 方法自动转换为字符串
d = new Date();
document.getElementById("demo1").innerHTML = d;
// 等同于
document.getElementById("demo2").innerHTML = d.toString();
//toUTCString() 方法将日期转换为 UTC 字符串(一种日期显示标准)。
document.getElementById("demo3").innerHTML = d.toUTCString();
//toDateString() 方法将日期转换为更易读的格式
document.getElementById('demo4').innerHTML = d.toDateString();
25、日期格式:没啥内容;无论输入哪种格式,输出的日期格式一样,JavaScript 默认将输出全文本字符串格式
ISO 日期 |
"2018-02-19" (国际标准) |
短日期 |
"02/19/2018" 或者 "2018/02/19" |
长日期 |
"Feb 19 2018" 或者 "19 Feb 2019" |
完整日期 |
"Monday February 25 2015" |
26、日期获取方法:
/**
getDate() 以数值返回天(1-31)
getDay() 以数值获取周名(0-6)
getFullYear() 获取四位的年(yyyy)
getHours() 获取小时(0-23)
getMilliseconds() 获取毫秒(0-999)
getMinutes() 获取分(0-59)
getMonth() 获取月(0-11)
getSeconds() 获取秒(0-59)
getTime() 获取时间(从 1970 年 1 月 1 日至今
* */
var d = new Date();
var d1 = d.getDate();
var d2 = d.getDay();
var d3 = d.getFullYear();
var d4 = d.getHours();
var d5 = d.getMilliseconds();
var d6 = d.getMinutes();
var d7 = d.getMonth();
var d8 = d.getSeconds();
var d9 = d.getTime();
console.log(d,d1, d2, d3, d4, d5, d6, d7, d8, d9)
// Sun Aug 25 2019 17:03:40 GMT+0800 (中国标准时间) 25 0 2019 17 862 3 7 40 1566723820862
/**
getUTCDate() 等于 getDate(),但返回 UTC 日期
getUTCDay() 等于 getDay(),但返回 UTC 日
getUTCFullYear() 等于 getFullYear(),但返回 UTC 年
getUTCHours() 等于 getHours(),但返回 UTC 小时
getUTCMilliseconds() 等于 getMilliseconds(),但返回 UTC 毫秒
getUTCMinutes() 等于 getMinutes(),但返回 UTC 分
getUTCMonth() 等于 getMonth(),但返回 UTC 月
getUTCSeconds() 等于 getSeconds(),但返回 UTC 秒
* */
var dd = new Date();
var dd1 = dd.getUTCDate();
var dd2 = dd.getUTCDay();
var dd3 = dd.getUTCFullYear();
var dd4 = dd.getUTCHours();
var dd5 = dd.getUTCMilliseconds();
var dd6 = dd.getUTCMinutes();
var dd7 = dd.getUTCMonth();
var dd8 = dd.getUTCSeconds();
console.log(dd,dd1,dd2,dd3,dd4,dd5,dd6,dd7,dd8);
// Sun Aug 25 2019 17:03:40 GMT+0800 (中国标准时间) 25 0 2019 9 862 3 7 40
27、日期设置方法:
/**
setDate() 以数值(1-31)设置日
setFullYear() 设置年(可选月和日)
setHours() 设置小时(0-23)
setMilliseconds() 设置毫秒(0-999)
setMinutes() 设置分(0-59)
setMonth() 设置月(0-11)
setSeconds() 设置秒(0-59)
setTime() 设置时间(从 1970 年 1 月 1 日至今的毫秒数)
* */
var d = new Date();
console.log(d);
d.setFullYear(2020);
console.log(d);
d.setFullYear(2020,11,3);
console.log(d);
d.setMonth(11);
console.log(d);
d.setDate(12);
console.log(d);
d.setDate(d.getDate() + 50);
console.log(d);
d.setHours(2);
console.log(d);
d.setMinutes(34);
console.log(d);
d.setSeconds(21);
console.log(d);
//比较日期
var today = new Date();
var someDay = new Date();
someDay.setFullYear(2022);
if (today > someDay){
console.log('今天在2022年之后');
} else {
console.log('今天在2022年之前');
}
28、数学
var a1 = Math.PI;
var a2 = Math.round(1.23);//的返回值是 x 四舍五入为最接近的整数
var a3 = Math.pow(8,2);//Math.pow(x, y) 的返回值是 x 的 y 次幂
var a4 = Math.sqrt(64);//Math.sqrt(x) 返回 x 的平方根
var a5 = Math.abs(-34);//Math.abs(x) 返回 x 的绝对(正)值
var a6 = Math.ceil(8.4);//Math.ceil(x) 的返回值是 x 上舍入最接近的整数
var a7 = Math.floor(4.2);//Math.floor(x) 的返回值是 x 下舍入最接近的整数
var a8 = Math.max(0,23,1,21,-3,4);
var a9 = Math.min(0,23,1,21,-3,4);
var a10 = Math.random();//[0,1)返回介于 0(包括) 与 1(不包括) 之间的随机数
console.log(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);
29、随机
// Math.random() 与 Math.floor() 一起使用用于返回随机整数
//返回0~9
var a1 = Math.floor(Math.random() * 10);
console.log(a1);
var a2 = Math.floor(Math.random() * 100)+1;//1~100
console.log(a2);
//一个适当的随机数
function getRndInteger(min,max) {
return Math.floor(Math.random()*(max - min))+min;
}
var num = getRndInteger(2,13);
console.log(num);
30、逻辑
过
31、比较
过
32、条件
过
33、Switch
过
34、Loop For
for循环 过
35、Loop While
while循环 过
36、Break
过
37、类型转换
// Number() 转换数值,String() 转换字符串,Boolean() 转换布尔值
/**
JavaScript 中有五种可包含值的数据类型:
字符串(string)
数字(number)
布尔(boolean)
对象(object)
函数(function)
有三种对象类型:
对象(Object)
日期(Date)
数组(Array)
同时有两种不能包含值的数据类型:
null
undefined
* */
//1、typeof typeof 运算符不是变量。它属于运算符。运算符(比如 + - * /)没有数据类型。但是,typeof 始终会返回字符串(包含运算数的类型)
typeof "Bill" // 返回 "string"
typeof 3.14 // 返回 "number"
typeof NaN // 返回 "number"
typeof false // 返回 "boolean"
typeof [1,2,3,4] // 返回 "object"
typeof {name:'Bill', age:62} // 返回 "object"
typeof new Date() // 返回 "object"
typeof function () {} // 返回 "function"
typeof myCar // 返回 "undefined" *
typeof null // 返回 "object"
//2、constructor 属性返回所有 JavaScript 变量的构造器函数
/*
"Bill".constructor // 返回 "function String() { [native code] }"
(3.14).constructor // 返回 "function Number() { [native code] }"
false.constructor // 返回 "function Boolean() { [native code] }"
[1,2,3,4].constructor // 返回 "function Array() { [native code] }"
{name:'Bill', age:62}.constructor // 返回" function Object() { [native code] }"
new Date().constructor // 返回 "function Date() { [native code] }"
function(){}.constructor // 返回 "function Function(){ [native code] }"
*/
//3、typeof查看不了具体类型,这时候可以用constructor判断具体类型
function isArray(myArray) {
return myArray.constructor.toString().indexOf("Array") > -1;
}
function isTArray(myArray) {
console.log(myArray.constructor);
return myArray.constructor === Array;
}
var array = ['d',12,true,'33'];
var is = isTArray(array);
console.log(is)
38、位运算
过
39、正则表达式 (TODO)
40、异常
41、作用域
42、Hoisting
43、严格模式
44、this关键字
45、Let
46、Const
47、调试
48、
你可能感兴趣的:(js,html,css)
- element实现动态路由+面包屑
软件技术NINI
vue案例vue.js前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件,它用于显示当前页面的路径,帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中,如果你已经安装了ElementUI,就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例:安装ElementUI(如果你还没有安装的话):你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
- swagger访问路径
igotyback
swagger
Swagger2.x版本访问地址:http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口,通常为8080。{context-path}是你的应用上下文路径,如果应用部署在根路径下,则为空。Swagger3.x版本对于Swagger3.x版本(也称为OpenAPI3)访问地址:http://{ip
- html 中如何使用 uniapp 的部分方法
某公司摸鱼前端
htmluni-app前端
示例代码:Documentconsole.log(window);效果展示:好了,现在就可以uni.使用相关的方法了
- C#中使用split分割字符串
互联网打工人no1
c#
1、用字符串分隔:usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果:aaabbbc
- 四章-32-点要素的聚合
彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记,使用的openlayers5.3.xapi。源码见1032.html,对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
- DIV+CSS+JavaScript技术制作网页(旅游主题网页设计与制作)云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业:【HTML5网页期末作业(1000套)】程序员有趣的告白方式:【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面:计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
- 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
若博豆
java算法华为javascript
华为OD2023(B卷)机试题库全覆盖,刷题指南点这里WeAreATeam时间限制:1秒|内存限制:32768K|语言限制:不限题目描述:总共有n个人在机房,每个人有一个标号(1<=标号<=n),他们分成了多个团队,需要你根据收到的m条消息判定指定的两个人是否在一个团队中,具体的:1、消息构成为:abc,整数a、b分别代
- 数组去重
好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考?如何去除数组中重复的项例如数组:[1,3,4,3,5]我们在做去重的时候,一开始想到的肯定是,逐个比较,外面一层循环,内层后一个与前一个一比较,如果是久不将当前这一项放进新的数组,挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低,代码量还多,思考?有没有更好的方法这时候不禁一想当然有了!!!hashtable啊,通过对象的hash办法
- 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材,DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业,Web大学生网页HTML:结构CSS:样式在操作方面上运用了html5和css3,采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
- HTML网页设计制作大作业(div+css) 云南我的家乡旅游景点 带文字滚动
二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
Web前端开发技术描述网页设计题材,DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML:结构CSS:样式在操作方面上运用了html5和css3,采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript:做与用户的交互行为文章目录前端学习路线
- 【JS】执行时长(100分) |思路参考+代码解析(C++)
l939035548
JS算法数据结构c++
题目为了充分发挥GPU算力,需要尽可能多的将任务交给GPU执行,现在有一个任务数组,数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务,一次执行耗时1秒,在保证GPU不空闲情况下,最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数,取值范围[1,10000]第二个参数为任务数组长度,取值范围[1,10000]第三个参数为任务数组,数字范围
- webpack图片等资源的处理
dmengmeng
需要的loaderfile-loader(让我们可以引入这些资源文件)url-loader(其实是file-loader的二次封装)img-loader(处理图片所需要的)在没有使用任何处理图片的loader之前,比如说css中用到了背景图片,那么最后打包会报错的,因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以,打开网页能准确看到图片。{test:/\.(p
- node.js学习
小猿L
node.jsnode.js学习vim
node.js学习实操及笔记温故node.js,node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础,三大框架vuereactangular离不开node.jsnode.js是什么官网:node.js是一个开源的、跨平台的运行JavaScript的运行
- docker
igotyback
eureka云原生
Docker容器的文件系统是隔离的,但是可以通过挂载卷(Volumes)或绑定挂载(BindMounts)将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径,可以使用以下方法:查看容器配置:使用dockerinspect命令可以查看容器的详细配置信息,包括挂载的卷。例如:bashdockerinspect在输出的JSON格式中,查找"Mounts"部分,这里会列出所有的挂载信息
- 在Ubuntu中编译含有JSON的文件出现报错
芝麻糊76
Linuxkill_buglinuxubuntujson
在ubuntu中进行JSON相关学习的时候,我发现了一些小问题,决定与大家进行分享,减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
- Xinference如何注册自定义模型
玩人工智能的辣条哥
人工智能AI大模型Xinference
环境:Xinference问题描述:Xinference如何注册自定义模型解决方案:1.写个model_config.json,内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
- Python神器!WEB自动化测试集成工具 DrissionPage
亚丁号
python开发语言
一、前言用requests做数据采集面对要登录的网站时,要分析数据包、JS源码,构造复杂的请求,往往还要应付验证码、JS混淆、签名参数等反爬手段,门槛较高。若数据是由JS计算生成的,还须重现计算过程,体验不好,开发效率不高。使用浏览器,可以很大程度上绕过这些坑,但浏览器运行效率不高。因此,这个库设计初衷,是将它们合而为一,能够在不同须要时切换相应模式,并提供一种人性化的使用方法,提高开发和运行效率
- Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net
佛一脚
errorreactmongodb数据库
背景每天都能遇到奇怪的问题,做个记录,以便有缘人能得到帮助!换了一台电脑开发nextjs程序。需要连接mongodb数据,对数据进行增删改查。上一台电脑好好的程序,新电脑死活连不上mongodb数据库。同一套代码,没任何修改,搞得我怀疑人生了,打开浏览器进入mongodb官网毫无问题,也能进入线上系统查看数据,网络应该是没问题。于是我尝试了一下手机热点,这次代码能正常跑起来,连接数据库了!!!是不
- Vue( ElementUI入门、vue-cli安装)
m0_l5z
elementuivue.js
一.ElementUI入门目录:1.ElementUI入门1.1ElementUI简介1.2Vue+ElementUI安装1.3开发示例2.搭建nodejs环境2.1nodejs介绍2.2npm是什么2.3nodejs环境搭建2.3.1下载2.3.2解压2.3.3配置环境变量2.3.4配置npm全局模块路径和cache默认安装位置2.3.5修改npm镜像提高下载速度2.3.6验证安装结果3.运行n
- 博客网站制作教程
2401_85194651
javamaven
首先就是技术框架:后端:Java+SpringBoot数据库:MySQL前端:Vue.js数据库连接:JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
- 00. 这里整理了最全的爬虫框架(Java + Python)
有一只柴犬
爬虫系列爬虫javapython
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
- 详解:如何设计出健壮的秒杀系统?
夜空_2cd3
作者:Yrion博客园:cnblogs.com/wyq178/p/11261711.html前言:秒杀系统相信很多人见过,比如京东或者淘宝的秒杀,小米手机的秒杀。那么秒杀系统的后台是如何实现的呢?我们如何设计一个秒杀系统呢?对于秒杀系统应该考虑哪些问题?如何设计出健壮的秒杀系统?本期我们就来探讨一下这个问题:image目录一:****秒杀系统应该考虑的问题二:****秒杀系统的设计和技术方案三:*
- vue 创建项目报错:command failed: npm install --loglevel error
那鱼、会飞
vue.jsvue-cli3
这个问题其实很好解决,只是很多种情况,逐一排除即可。稳下心来~vuecli3创建项目我的node版本是node14.15.0,(永远不要尝试最新版本)node各种版本下载地址:以往的版本|Node.js(nodejs.org)vue/cli@3.12.1npminstall-g@vue/cli@3.12.1(注意vue/cli2和vue/cli3的下载命名有所改变,2是-形式,3是/形式)其实报错
- 更改npm镜像源为淘宝镜像
骆小骆
基于node.js
npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies(生产环境依赖)中,即你的package.json文件的dependencies字段中;–--save-dev、-D参数意思是把模块版本信息保存到devDependencies(开发环境依赖)中,即你的package.json文件的de
- COCO 格式的数据集转化为 YOLO 格式的数据集
QYQY77
YOLOpython
"""--json_path输入的json文件路径--save_path保存的文件夹名字,默认为当前目录下的labels。"""importosimportjsonfromtqdmimporttqdmimportargparseparser=argparse.ArgumentParser()parser.add_argument('--json_path',default='./instances
- NPM私库搭建-verdaccio(Linux)
Beam007
npmlinux前端
1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件,解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改:/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
- 斟一小组鸡血视频
和自己一起成长
http://m.v.qq.com/play/play.html?coverid=&vid=c0518henl2a&ptag=2_6.0.0.14297_copy有一种努力叫做靠自己http://m.v.qq.com/play/play.html?coverid=&vid=i0547o426g4&ptag=2_6.0.0.14297_copy世界最励志短片https://v.qq.com/x/pa
- 前端代码上传文件
余生逆风飞翔
前端javascript开发语言
点击上传文件import{ElNotification}from'element-plus'import{API_CONFIG}from'../config/index.js'import{UploadFilled}from'@element-plus/icons-vue'import{reactive}from'vue'import{BASE_URL}from'../config/index'i
- golang获取用户输入的几种方式
余生逆风飞翔
golang开发语言后端
一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
- Dockerfile命令详解之 FROM
清风怎不知意
容器化java前端javascript
许多同学不知道Dockerfile应该如何写,不清楚Dockerfile中的指令分别有什么意义,能达到什么样的目的,接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是,按照惯例,它们应该是大写的,以便更容易地将它们与参数区分开来。(引用
- HQL之投影查询
归来朝歌
HQLHibernate查询语句投影查询
在HQL查询中,常常面临这样一个场景,对于多表查询,是要将一个表的对象查出来还是要只需要每个表中的几个字段,最后放在一起显示?
针对上面的场景,如果需要将一个对象查出来:
HQL语句写“from 对象”即可
Session session = HibernateUtil.openSession();
- Spring整合redis
bylijinnan
redis
pom.xml
<dependencies>
<!-- Spring Data - Redis Library -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redi
- org.hibernate.NonUniqueResultException: query did not return a unique result: 2
0624chenhong
Hibernate
参考:http://blog.csdn.net/qingfeilee/article/details/7052736
org.hibernate.NonUniqueResultException: query did not return a unique result: 2
在项目中出现了org.hiber
- android动画效果
不懂事的小屁孩
android动画
前几天弄alertdialog和popupwindow的时候,用到了android的动画效果,今天专门研究了一下关于android的动画效果,列出来,方便以后使用。
Android 平台提供了两类动画。 一类是Tween动画,就是对场景里的对象不断的进行图像变化来产生动画效果(旋转、平移、放缩和渐变)。
第二类就是 Frame动画,即顺序的播放事先做好的图像,与gif图片原理类似。
- js delete 删除机理以及它的内存泄露问题的解决方案
换个号韩国红果果
JavaScript
delete删除属性时只是解除了属性与对象的绑定,故当属性值为一个对象时,删除时会造成内存泄露 (其实还未删除)
举例:
var person={name:{firstname:'bob'}}
var p=person.name
delete person.name
p.firstname -->'bob'
// 依然可以访问p.firstname,存在内存泄露
- Oracle将零干预分析加入网络即服务计划
蓝儿唯美
oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是,Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务(NaaS)平台,帮助企业以更灵活和更适合云的方式实现通信服务提供商(CSP)的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
- spring学习——springmvc(二)
a-john
springMVC
Spring MVC提供了非常方便的文件上传功能。
1,配置Spring支持文件上传:
DispatcherServlet本身并不知道如何处理multipart的表单数据,需要一个multipart解析器把POST请求的multipart数据中抽取出来,这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器,需要声明一个实现了Mul
- POJ-2828-Buy Tickets
aijuans
ACM_POJ
POJ-2828-Buy Tickets
http://poj.org/problem?id=2828
线段树,逆序插入
#include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
- Java Ant build.xml详解
asia007
build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到,形象来说,你要把代码从某个地方拿来,编译,再拷贝到某个地方去等等操作,当然不仅与此,但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的,所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多,可能你用了很久,你仍然不知道它能有
- android按钮监听器的四种技术
百合不是茶
androidxml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;
1,activity中使用内部类实现接口 ,创建内部类实例 使用add方法 与java类似
创建监听器的实例
myLis lis = new myLis();
使用add方法给按钮添加监听器
- 软件架构师不等同于资深程序员
bijian1013
程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师,他居住在伦敦,他参与过的开源项目包括 Apache Lucene,,Apache Nutch, Liferay 和 Pentaho等。
如今很多的公司
- TeamForge Wiki Syntax & CollabNet User Information Center
sunjing
TeamForgeHow doAttachementAnchorWiki Syntax
the CollabNet user information center http://help.collab.net/
How do I create a new Wiki page?
A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
- 【Redis四】Redis数据类型
bit1129
redis
概述
Redis是一个高性能的数据结构服务器,称之为数据结构服务器的原因是,它提供了丰富的数据类型以满足不同的应用场景,本文对Redis的数据类型以及对这些类型可能的操作进行总结。
Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统,这里的数据类型指的是value的类型,而不是key的类型,key的类型只有一种即string
- SSH2整合-附源码
白糖_
eclipsespringtomcatHibernateGoogle
今天用eclipse终于整合出了struts2+hibernate+spring框架。
我创建的是tomcat项目,需要有tomcat插件。导入项目以后,鼠标右键选择属性,然后再找到“tomcat”项,勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片,sql也在源码里。
补充1:项目中部分jar包不是最新版的,可能导
- [转]开源项目代码的学习方法
braveCS
学习方法
转自:
http://blog.sina.com.cn/s/blog_693458530100lk5m.html
http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html
1)阅读features。以此来搞清楚该项目有哪些特性2)思考。想想如果自己来做有这些features的项目该如何构架3)下载并安装d
- 编程之美-子数组的最大和(二维)
bylijinnan
编程之美
package beautyOfCoding;
import java.util.Arrays;
import java.util.Random;
public class MaxSubArraySum2 {
/**
* 编程之美 子数组之和的最大值(二维)
*/
private static final int ROW = 5;
private stat
- 读书笔记-3
chengxuyuancsdn
jquery笔记resultMap配置ibatis一对多配置
1、resultMap配置
2、ibatis一对多配置
3、jquery笔记
1、resultMap配置
当<select resultMap="topic_data">
<resultMap id="topic_data">必须一一对应。
(1)<resultMap class="tblTopic&q
- [物理与天文]物理学新进展
comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境
怎么办呢?
 
- Oracle 11g新特性:Automatic Diagnostic Repository
daizj
oracleADR
Oracle Database 11g的FDI(Fault Diagnosability Infrastructure)是自动化诊断方面的又一增强。
FDI的一个关键组件是自动诊断库(Automatic Diagnostic Repository-ADR)。
在oracle 11g中,alert文件的信息是以xml的文件格式存在的,另外提供了普通文本格式的alert文件。
这两份log文
- 简单排序:选择排序
dieslrae
选择排序
public void selectSort(int[] array){
int select;
for(int i=0;i<array.length;i++){
select = i;
for(int k=i+1;k<array.leng
- C语言学习六指针的经典程序,互换两个数字
dcj3sjt126com
c
示例程序,swap_1和swap_2都是错误的,推理从1开始推到2,2没完成,推到3就完成了
# include <stdio.h>
void swap_1(int, int);
void swap_2(int *, int *);
void swap_3(int *, int *);
int main(void)
{
int a = 3;
int b =
- php 5.4中php-fpm 的重启、终止操作命令
dcj3sjt126com
PHP
php 5.4中php-fpm 的重启、终止操作命令:
查看php运行目录命令:which php/usr/bin/php
查看php-fpm进程数:ps aux | grep -c php-fpm
查看运行内存/usr/bin/php -i|grep mem
重启php-fpm/etc/init.d/php-fpm restart
在phpinfo()输出内容可以看到php
- 线程同步工具类
shuizhaosi888
同步工具类
同步工具类包括信号量(Semaphore)、栅栏(barrier)、闭锁(CountDownLatch)
闭锁(CountDownLatch)
public class RunMain {
public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
fin
- bleeding edge是什么意思
haojinghua
DI
不止一次,看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件,上了wiki。
我再一次感到,没有辞典能像WiKi一样,给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱,只好在此一一中英对照,给大家上次课。
In computer science, bleeding edge is a term that
- c中实现utf8和gbk的互转
jimmee
ciconvutf8&gbk编码
#include <iconv.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
int code_c
- 大型分布式网站架构设计与实践
lilin530
应用服务器搜索引擎
1.大型网站软件系统的特点?
a.高并发,大流量。
b.高可用。
c.海量数据。
d.用户分布广泛,网络情况复杂。
e.安全环境恶劣。
f.需求快速变更,发布频繁。
g.渐进式发展。
2.大型网站架构演化发展历程?
a.初始阶段的网站架构。
应用程序,数据库,文件等所有的资源都在一台服务器上。
b.应用服务器和数据服务器分离。
c.使用缓存改善网站性能。
d.使用应用
- 在代码中获取Android theme中的attr属性值
OliveExcel
androidtheme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.
在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则:
int defaultColor = 0xFF000000;
int[] attrsArray = { andorid.r.
- 基于Zookeeper的分布式共享锁
roadrunners
zookeeper分布式共享锁
首先,说说我们的场景,订单服务是做成集群的,当两个以上结点同时收到一个相同订单的创建指令,这时并发就产生了,系统就会重复创建订单。等等......场景。这时,分布式共享锁就闪亮登场了。
共享锁在同一个进程中是很容易实现的,但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译,这里就不在赘述了。
官
- 两个容易被忽略的MySQL知识
tomcat_oracle
mysql
1、varchar(5)可以存储多少个汉字,多少个字母数字? 相信有好多人应该跟我一样,对这个已经很熟悉了,根据经验我们能很快的做出决定,比如说用varchar(200)去存储url等等,但是,即使你用了很多次也很熟悉了,也有可能对上面的问题做出错误的回答。 这个问题我查了好多资料,有的人说是可以存储5个字符,2.5个汉字(每个汉字占用两个字节的话),有的人说这个要区分版本,5.0
- zoj 3827 Information Entropy(水题)
阿尔萨斯
format
题目链接:zoj 3827 Information Entropy
题目大意:三种底,计算和。
解题思路:调用库函数就可以直接算了,不过要注意Pi = 0的时候,不过它题目里居然也讲了。。。limp→0+plogb(p)=0,因为p是logp的高阶。
#include <cstdio>
#include <cstring>
#include <cmath&
|