静修-个人博客


  • 首页

  • 分类

  • 归档

  • 标签

  • 搜索

17-列表函数

发表于 2018-05-03 | 分类于 前端-07-scss

列表函数主要包括一些对列表参数的函数使用,主要包括以下几种:

  • length($list):返回一个列表的长度值;
  • nth($list, $n):返回一个列表中指定的某个标签值
  • join($list1, $list2, [$separator]):将两个列给连接在一起,变成一个列表;
  • append($list1, $val, [$separator]):将某个值放在列表的最后;
  • zip($lists…):将几个列表结合成一个多维的列表;
  • index($list, $value):返回一个值在列表中的位置值。

    列表函数中的每个函数都有其独特的作用与功能,接下来我们通过命令终端向大家展示每个列表函数的功能与使用。

length()函数

length() 函数主要用来返回一个列表中有几个值,简单点说就是返回列表清单中有多少个值:

1
2
3
4
5
6
>> length(10px)
1
>> length(10px 20px (border 1px solid) 2em)
4
>> length(border 1px solid)
3

==length() 函数中的列表参数之间使用空格隔开,不能使用逗号,否则函数将会出错:

1
2
3
4
>> length(10px,20px,(border 1px solid),2em)
SyntaxError: wrong number of arguments (4 for 1) for `length'
>> length(1,2px)
SyntaxError: wrong number of arguments (2 for 1) for `length'

nth()函数

语法:

1
nth($list,$n)

nth() 函数用来指定列表中某个位置的值。不过在 Sass 中,nth() 函数和其他语言不同,1 是指列表中的第一个标签值,2 是指列给中的第二个标签值,依此类推。如:

1
2
3
4
5
6
>> nth(10px 20px 30px,1)
10px
>> nth((Helvetica,Arial,sans-serif),2)
"Arial"
>> nth((1px solid red) border-top green,1)
(1px "solid" #ff0000)

注:在 nth($list,$n) 函数中的 $n 必须是大于 0 的整数:

1
2
>> nth((1px solid red) border-top green 1 ,0)
SyntaxError: List index 0 must be a non-zero integer for `nth'

join()函数

join() 函数是将两个列表连接合并成一个列表。

1
2
3
4
5
6
>> join(10px 20px, 30px 40px)
(10px 20px 30px 40px)
>> join((blue,red),(#abc,#def))
(#0000ff, #ff0000, #aabbcc, #ddeeff)
>> join((blue,red),(#abc #def))
(#0000ff, #ff0000, #aabbcc, #ddeeff)

不过 join() ==只能将两个列表==连接成一个列表,如果直接连接两个以上的列表将会报错:

1
2
>> join((blue red),(#abc, #def),(#dee #eff))
SyntaxError: $separator: (#ddeeee #eeffff) is not a string for `join'

但很多时候不只碰到两个列表连接成一个列表,这个时候就需要将多个 join() 函数合并在一起使用:

1
2
>> join((blue red), join((#abc #def),(#dee #eff)))
(#0000ff #ff0000 #aabbcc #ddeeff #ddeeee #eeffff)

在 join() 函数中还有一个很特别的参数 $separator,这个参数主要是用来给列表函数连接列表值是,使用的分隔符号,默认值为 auto。

join() 函数中 $separator 除了默认值 auto 之外,还有 comma 和 space 两个值,其中 comma 值指定列表中的列表项值之间使用逗号(,)分隔,space 值指定列表中的列表项值之间使用空格( )分隔。

在 join() 函数中除非明确指定了 $separator值,否则将会有多种情形发生:

如果列表中的第一个列表中每个值之间使用的是逗号(,),那么 join() 函数合并的列表中每个列表项之间使用逗号,分隔:

1
2
>> join((blue, red, #eff),(green orange))
(#0000ff, #ff0000, #eeffff, #008000, #ffa500)

但当第一个列表中只有一个列表项,那么 join() 函数合并的列表项目中每个列表项目这间使用的分隔符号会根据第二个列表项中使用的,如果第二列表项中使用是,分隔,则使用逗号分隔;如果第二列项之间使用的空格符,则使用空格分隔:

1
2
3
4
>> join(blue,(green, orange))
(#0000ff, #008000, #ffa500)
>> join(blue,(green orange))
(#0000ff #008000 #ffa500)

如果列表中的第一个列表中每个值之间使用的是空格,那么 join() 函数合并的列表中每个列表项之间使用空格分隔:

1
2
3
4
>> join((blue green),(red,orange))
(#0000ff #008000 #ff0000 #ffa500)
>> join((blue green),(red orange))
(#0000ff #008000 #ff0000 #ffa500)

如果当两个列表中的列表项小于1时,将会以空格分隔:

1
2
>> join(blue,red)
(#0000ff #ff0000)

如此一来,会有多种情形发生,造成使用混乱的情形,如果你无法记得,什么时候会是用逗号分隔合并的列表项,什么时候是使用空格分隔合并 的列表项,在些建议大家使用 join() 函数合并列表项的时候就明确指定 $separator 参数,用来指定合并的列表中使用什么方式来分隔列表项:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>> join(blue,red,comma)
(#0000ff, #ff0000)
>> join(blue,red,space)
(#0000ff #ff0000)
>> join((blue green),(red,orange),comma)
(#0000ff, #008000, #ff0000, #ffa500)
>> join((blue green),(red,orange),space)
(#0000ff #008000 #ff0000 #ffa500)
>> join((blue, green),(red,orange),comma)
(#0000ff, #008000, #ff0000, #ffa500)
>> join((blue, green),(red,orange),space)
(#0000ff #008000 #ff0000 #ffa500)
>> join(blue,(red,orange),comma)
(#0000ff, #ff0000, #ffa500)
>> join(blue,(red,orange),space)
(#0000ff #ff0000 #ffa500)
>> join(blue,(red orange),comma)
(#0000ff, #ff0000, #ffa500)
>> join(blue,(red orange),space)
(#0000ff #ff0000 #ffa500)

append()函数

append() 函数是用来将某个值插入到列表中,并且处于最末位。

1
2
3
4
5
6
7
8
>> append(10px 20px ,30px)
(10px 20px 30px)
>> append((10px,20px),30px)
(10px, 20px, 30px)
>> append(green,red)
(#008000 #ff0000)
>> append(red,(green,blue))
(#ff0000 (#008000, #0000ff))

如果没有明确的指定 $separator 参数值,其默认值是 auto。

  • 如果列表只有一个列表项时,那么插入进来的值将和原来的值会以空格的方式分隔。
  • 如果列表中列表项是以空格分隔列表项,那么插入进来的列表项也将以空格分隔;
  • 如果列表中列表项是以逗号分隔列表项,那么插入进来的列表项也将以逗号分隔。

当然,在 append() 函数中,可以显示的设置 $separator 参数,

  • 如果取值为 comma 将会以逗号分隔列表项
  • 如果取值为 space 将会以空格分隔列表项
1
2
3
4
5
6
7
8
9
10
11
12
>> append((blue green),red,comma)
(#0000ff, #008000, #ff0000)
>> append((blue green),red,space)
(#0000ff #008000 #ff0000)
>> append((blue, green),red,comma)
(#0000ff, #008000, #ff0000)
>> append((blue, green),red,space)
(#0000ff #008000 #ff0000)
>> append(blue,red,comma)
(#0000ff, #ff0000)
>> append(blue,red,space)
(#0000ff #ff0000)

zip()函数

zip()函数将多个列表值转成一个多维的列表:

1
2
>> zip(1px 2px 3px,solid dashed dotted,green blue red)
((1px "solid" #008000), (2px "dashed" #0000ff), (3px "dotted" #ff0000))

index()函数

index() 函数类似于索引一样,主要让你找到某个值在列表中所处的位置。在 Sass 中,第一个值就是1,第二个值就是 2,依此类推:

1
2
3
4
5
6
>> index(1px solid red, 1px)
1
>> index(1px solid red, solid)
2
>> index(1px solid red, red)
3

在 index() 函数中,如果指定的值不在列表中(没有找到相应的值),那么返回的值将是 false,相反就会返回对应的值在列表中所处的位置。

1
2
3
4
>> index(1px solid red,dotted) //列表中没有找到 dotted
false
>> index(1px solid red,solid) //列表中找到 solid 值,并且返回他的位置值 2
2

Introspection函数

Introspection 函数包括了几个判断型函数:

  • type-of($value):返回一个值的类型
  • unit($number):返回一个值的单位
  • unitless($number):判断一个值是否带有单位
  • comparable($number-1, $number-2):判断两个值是否可以做加、减和合并

这几个函数主要用来对值做一个判断的作用,我们来依次看每个函数的功能。

Introspection 函数 -type-of()

type-of() 函数主要用来判断一个值是属于什么类型:

返回值:

  • number 为数值型。
  • string 为字符串型。
  • bool 为布尔型。
  • color 为颜色型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>> type-of(100)
"number"
>> type-of(100px)
"number"
>> type-of("asdf")
"string"
>> type-of(asdf)
"string"
>> type-of(true)
"bool"
>> type-of(false)
"bool"
>> type-of(#fff)
"color"
>> type-of(blue)
"color"
>> type-of(1 / 2 = 1)
"string"

unit()函数

unit() 函数主要是用来获取一个值所使用的单位,碰到复杂的计算时,其能根据运算得到一个“多单位组合”的值,不过只充许乘、除运算:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>> unit(100)
""
>> unit(100px)
"px"
>> unit(20%)
"%"
>> unit(1em)
"em"
>> unit(10px * 3em)
"em*px"
>> unit(10px / 3em)
"px/em"
>> unit(10px * 2em / 3cm / 1rem)
"em/rem"

但加、减碰到不同单位时,unit() 函数将会报错,除 px 与 cm、mm 运算之外:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>> unit(1px + 1cm)
"px"
>> unit(1px - 1cm)
"px"
>> unit(1px + 1mm)
"px"
>> unit(10px * 2em - 3cm / 1rem)
SyntaxError: Incompatible units: 'cm' and 'px*em'.
>> unit(10px * 2em - 1px / 1rem)
SyntaxError: Incompatible units: '' and 'em'.
>> unit(1px - 1em)
SyntaxError: Incompatible units: 'em' and 'px'.
>> unit(1px - 1rem)
SyntaxError: Incompatible units: 'rem' and 'px'.
>> unit(1px - 1%)
SyntaxError: Incompatible units: '%' and 'px'.
>> unit(1cm + 1em)
SyntaxError: Incompatible units: 'em' and 'cm'.

unit() 函数对于单位运算相对来说也没有规律,而且有些单位也无法整合成一个单位,对于我们在 CSS 中运用中并不适合,比如:

1
2
3
4
5
6
>> unit(10px * 3em)
"em*px"
>> unit(10px / 3em)
"px/em"
>> unit(10px * 2em / 3cm / 1rem)
"em/rem"

换句话说,上面运算出来的单位,对于在 CSS 中使用将是没有任何意义的。

unitless()函数

unitless() 函数相对来说简单明了些,只是用来判断一个值是否带有单位,如果不带单位返回的值为 true,带单位返回的值为 false:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>> unitless(100)
true
>> unitless(100px)
false
>> unitless(100em)
false
>> unitless(100%)
false
>> unitless(1 /2 )
true
>> unitless(1 /2 + 2 )
true
>> unitless(1px /2 + 2 )
false

comparable()函数

comparable() 函数主要是用来判断两个数是否可以进行“加,减”以及“合并”。如果可以返回的值为 true,如果不可以返回的值是 false:

Miscellaneous函数

在这里把 Miscellaneous 函数称为三元条件函数,主要因为他和 JavaScript 中的三元判断非常的相似。他有两个值,当条件成立返回一种值,当条件不成立时返回另一种值:

1
if($condition,$if-true,$if-false)

上面表达式的意思是当 $condition 条件成立时,返回的值为

1
2
3
4
5
$if-true,否则返回的是 $if-false 值。
>> if(true,1px,2px)
1px
>> if(false,1px,2px)
2px

Map

Sass 的 map 长得与 JSON 极其相似:

1
2
3
4
5
$map: (
$key1: value1,
$key2: value2,
$key3: value3
)

首先有一个类似于 Sass 的变量一样,用个 $ 加上命名空间来声明 map。后面紧接是一个小括号 (),将数据以 key:value 的形式赋予,其中 key 和 value 是成对出现,并且每对之间使用逗号 (,) 分隔,其中最后一组后面没有逗号。

其中键 key 是用来查找相关联的值 value。使用 map 可以很容易收集键的值和动态插入。我们来回忆一下,在 Sass 中常用下面的方式定义变量:

1
2
$default-color: #fff !default;
$primary-color: #22ae39 !default;

我们使用 map 可以更好的进行管理:

1
2
3
4
$color: (
default: #fff,
primary: #22ae39
);

$default-color: #fff !default;
$primary-color: #22ae39 !default;

我们使用 map 可以更好的进行管理:

1
2
3
4
$color: (
default: #fff,
primary: #22ae39
);

对于 Sass 的 map,还可以让 map 嵌套 map。其实就是 map 的某一个 key 当成 map,里面可以继续放一对或者多对

1
2
3
4
5
6
7
8
9
key:value:
$map: (
key1: value1,
key2: (
key-1: value-1,
key-2: value-2,
),
key3: value3
);

Sass Maps的函数

前面介绍了使用 map 来管理变量,但要在 Sass 中获取变量,或者对 map 做更多有意义的操作,我们必须借助于 map 的函数功能。在 Sass 中 map 自身带了七个函数:

  • map-get($map,$key):根据给定的 key 值,返回 map 中相关的值。
  • map-merge($map1,$map2):将两个 map 合并成一个新的 map。
  • map-remove($map,$key):从 map 中删除一个 key,返回一个新 map。
  • map-keys($map):返回 map 中所有的 key。
  • map-values($map):返回 map 中所有的 value。
  • map-has-key($map,$key):根据给定的 key 值判断 map 是否有对应的 value 值,如果有返回 true,否则返回 false。
  • keywords($args):返回一个函数的参数,这个参数可以动态的设置 key 和 value。

Sass Maps的函数-map-get($map,$key)

map-get($map,$key) 函数的作用是根据 $key 参数,返回 $key 在 $map 中对应的 value 值。如果 $key 不存在 $map中,将返回 null 值。此函数包括两个参数:

  • $map:定义好的 map。
  • $key:需要遍历的 key。

来看一个简单的示例,假设定义了一个 $social-colors 的 map:

1
2
3
4
5
6
7
$social-colors: (
dribble: #ea4c89,
facebook: #3b5998,
github: #171515,
google: #db4437,
twitter: #55acee
);

假设要获取 facebook 键值对应的值 #3b5998,我们就可以使用 map-get() 函数来实现:

1
2
3
.btn-dribble{
color: map-get($social-colors,facebook);
}

编译出来的CSS:

1
2
3
.btn-dribble {
color: #3b5998;
}

我们来看另一种情况,假设 $social-colors 这个 map 没有 $weibo 这个 key:

1
2
3
4
.btn-weibo{
font-size: 12px;
color: map-get($social-colors,weibo);
}

此时编译出来的是CSS:

1
2
3
.btn-weibo {
font-size: 12px;
}

从 编译出来的 CSS 可以得知,如果 $key 不在 $map 中,不会编译出 CSS,其实在 Sass 中,map-get($social- colors,weibo) 返回了一个 null 值。但在编译出来的 CSS 中,你只知道他没有编译出样式,而且在命令终端编译时,也没有任何错误或者警告信息。说实话,你并不知道他为什么编译不出来样式,或者说他已返回了值为 null。体验不强,也不好排错。其实如果我们自定义一个函数,另外加个判断,那就截然不同。

Sass Maps的函数-map-has-key($map,$key)

map-has-key($map,$key) 函数将返回一个布尔值。当 $map 中有这个 $key,则函数返回 true,否则返回 false。

前面的示例,当 $key 不在 $map 中时,使用 map-get($map,$key) 函数将返回一个 null 值。但对于开发人员,并看不到任何提示信息。如果使用 map-has-key($map,$key) 函数就可以改变这一状态。我们来看一个简单的示例。

1
2
3
4
5
6
7
@if map-has-key($social-colors,facebook){
.btn-facebook {
color: map-get($social-colors,facebook);
}
} @else {
@warn "No color found for faceboo in $social-colors map. Property ommitted."
}

编译出来:

1
2
3
.btn-fackbook{
color: #3b5998;
}

Sass Maps的函数-map-keys($map)

map-keys($map) 函数将会返回 $map 中的所有 key。这些值赋予给一个变量,那他就是一个列表。如:

1
map-keys($social-colors);

其返回的值为:

1
"dribble","facebook","github","google","twitter"

换句话说:

1
$list: map-keys($social-colors);

相当于:

1
$list:"dribble","facebook","github","google","twitter";

这个时候,就可以配合 Sass 的 list 做很多事情。

上面的示例,可以做通过 map-keys($map) 来做一个修改:
@function colors($color){

1
2
3
4
5
6
$names: map-keys($social-colors);
@if not index($names,$color){
@warn "Waring: `#{$color} is not a valid color name.`";
}
@return map-get($social-colors,$color);
}

上面代码中最不同之处,我们使 用map-key s将 $social-colors 这个 map 的所有 key 取出,并赋予给一个名 为 $names 的列表。然后通过 index($names,$color) 返回 $color 在 $names 位置,如果这个位置不存在,将返回提示信息,如果存在将返回正确的值。

1
2
3
.btn-weibo{
color: colors(weibo);
}

Sass Maps的函数-map-values($map)、map-merge($map1,$map2)

map-values($map)

map-values($map) 函数类似于 map-keys($map) 功能,不同的是 map-values($map )获取的是 $map 的所有 value 值,可以说也将是一个列表。而且,map-values($map) 中如果有相同的 value 也将会全部获取出来。

如前面的示例,使用:

1
map-values($social-colors)

将会返回:

1
#ea4c89,#3b5998,#171515,#db4437,#55acee

值与值之前同样用逗号分隔。

1
map-merge($map1,$map2)

map-merge($map1,$map2)

map-merge($map1,$map2) 函数是将 $map1 和 $map2 合并,然后得到一个新的 $map。如果你要快速将新的值插入到 $map 中的话,这种方法是最佳方法。假设我们有两个 $map:

1
2
3
4
5
6
7
8
9
10
$color: (
text: #f36,
link: #f63,
border: #ddd,
backround: #fff
);
$typo:(
font-size: 12px,
line-height: 1.6
);

如果希望将这两个 $map 合并成一个 map,我们只要这样做:
$newmap: map-merge($color,$typo);

将会生成一个新的 map:

1
2
3
4
5
6
7
8
$newmap:(
text: #f36,
link: #f63,
border: #ddd,
background: #fff,
font-size: 12px,
line-height: 1.6
);

这样你就可以借助 map-get( ) 等函数做其他事情了。

不过有一点需要注意,如果 $map1 和 $map2 中有相同的 $key 名,那么将 $map2 中的 $key 会取代 $map1 中的:

1
2
3
4
5
6
7
8
9
10
11
12
$color: (
text: #f36,
link: #f63,
border: #ddd,
backround: #fff
);
$typo:(
font-size: 12px,
line-height: 1.6,
border: #ccc,
background: #000
);

执行:
$newmap: map-merge($color,$typo);

得到的新 map:

1
2
3
4
5
6
7
8
$newmap:(
text: #f36,
link: #f63,
font-size: 12px,
line-height: 1.6,
border: #ccc,
background: #000
);

Sass Maps的函数-map-remove($map,$key)、keywords($args)

map-remove($map,$key) 函数是用来删除当前 $map 中的某一个 $key,从而得到一个新的 map。其返回的值还是一个 map。他并不能直接从一个 map 中删除另一个 map,仅能通过删除 map 中的某个 key 得到新 map。如:

1
$map:map-remove($social-colors,dribble);

返回的是一个新 map:

1
2
3
4
5
6
$map:(
facebook: #3b5998,
github: #171515,
google: #db4437,
twitter: #55acee
);

如果删除的 key 并不存在于 $map 中,那么 map-remove() 函数返回的新 map 和以前的 map 一样。

1
$map:map-remove($social-colors,weibo);

返回的值:

1
2
3
4
5
6
7
8
$map: (
dribble: #ea4c89,
facebook: #3b5998,
github: #171515,
google: #db4437,
twitter: #55acee
);
keywords($args)

keywords($args)

keywords($args) 函数可以说是一个动态创建 map 的函数。可以通过混合宏或函数的参数变创建 map。参数也是成对出现,其中 $args 变成 key(会自动去掉$符号),而 $args 对应的值就是value。

1
2
3
4
5
6
7
8
9
10
11
@mixin map($args...){
@debug keywords($args);
}

@include map(
$dribble: #ea4c89,
$facebook: #3b5998,
$github: #171515,
$google: #db4437,
$twitter: #55acee
);

在命令终端可以看到一个输入的 @debug 信息:

1
DEBUG: (dribble: #ea4c89, facebook: #3b5998, github: #171515, google: #db4437, twitter: #55acee)

18-颜色函数

发表于 2018-05-03 | 分类于 前端-07-scss

在 Sass 的官方文档中,列出了 Sass 的颜色函数清单,从大的方面主要分为 RGB , HSL 和 Opacity 三大函数,当然其还包括一些其他的颜色函数,比如说 adjust-color 和 change-color 等。在这章节中,将主要和大家一起探讨 Sass 颜色函数中常见的 RGB、HSL 和 Opacity 函数。

1、RGB颜色函数

RGB 颜色只是颜色中的一种表达式,其中 R 是 red 表示红色,G 是 green 表示绿色而 B 是 blue 表示蓝色。在 Sass 中为 RGB 颜色提供六种函数:

  • rgb($red,$green,$blue):根据红、绿、蓝三个值创建一个颜色;
  • rgba($red,$green,$blue,$alpha):根据红、绿、蓝和透明度值创建一个颜色;
  • red($color):从一个颜色中获取其中红色值;
  • green($color):从一个颜色中获取其中绿色值;
  • blue($color):从一个颜色中获取其中蓝色值;
  • mix($color-1,$color-2,[$weight]):把两种颜色混合在一起。

接下来,分别在终端使用 RGB 函数来进行计算,看其最终结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
$ sass -i
>> rgb(200,40,88) //根据r:200,g:40,b:88计算出一个十六进制颜色值
#c82858
>> rgba(#c82858,.65) //根据#c82858的65%透明度计算出一个rgba颜色值
rgba(200, 40, 88, 0.65)
>> red(#c82858) //从#c82858颜色值中得到红色值 200
200
>> green(#c82858) //从#c82858颜色值中得到绿色值 40
40
>> blue(#c82858) //从#c82858颜色值中得到蓝色值 88
88
>> mix(#c82858,rgba(200,40,80,.65),.3) //把#c82858和rgba(200,40,88,.65) 两颜色按比例混合得到一个新颜色
rgba(200, 40, 80, 0.65105)

从上面的简单运算结果可以很清晰的知道。在 RGB 颜色函数中,在实际中常用的主要是 rgba() 和 mix() 两个函数,而 rgb() 函数只能快速的将一个 rgb 颜色转换成十六进制颜色表达,red()、green() 和 blue() 函数,只能取得某一颜色的一个值,对于颜色上使用并无太大作用(或许他的好处,我还没有理解过来)。接下来,主要来实战一下 rgba() 和 mix() 函数在实际中的运用。

RGB颜色函数-RGBA()函数

rgba() 函数主要用来将一个颜色根据透明度转换成 rgba 颜色。

其语法有两种格式:

1
2
rgba($red,$green,$blue,$alpha)  //将一个rgba颜色转译出来,和未转译的值一样
rgba($color,$alpha) //将一个Hex颜色转换成rgba颜色

其中 rgba($color,$alpha) 函数作用更大,主要运用在这样的情形之中:假设在实际中知道的颜色值是 #f36 或者 red,但在使用中,需要给他们配上一个透明度,这个时候在原来的 CSS 中,首先需要通过制图工具,得到 #f36 或 red 颜色的 R、G、B 值,而不能直接使用(注意 css3 是可以的,但是存在浏览器兼容问题):

1
2
//CSS
color: rgba(#f36,.5); //在css中,这是无效的写法

但在 Sass 中,RGBA() 函数就能解决这个问题。我们先来看一个简单的例子,假设在变量中定义了一个基本的变量:
$color: #f36;
$bgColor: orange;
$borderColor:green;
同时给他们加上 .5 的透明度:
//SCSS
.rgba {
color: rgba(#f36,.5);
background: rgba(orange,.5);
border-color: rgba(green,.5);
}
语法:

在这个实例中,我们使用了 Sass 的 rgba 函数,在括号是函数的参数,第一个参数是需要转换的颜色,他可以是任何颜色的表达方式,也可以是一个颜色变量;第二个参数是颜色的透明度,其值是 0~1 之间。上面的代码转译出来:

1
2
3
4
5
.rgba {
color: rgba(255, 51, 102, 0.5);
background: rgba(255, 165, 0, 0.5);
border-color: rgba(0, 128, 0, 0.5);
}

在来看一个调用前面定义的变量:

1
2
3
4
5
6
//SCSS
.rgba {
color: rgba($color,.5);
background: rgba($bgColor,.5);
border-color: rgba($borderColor,.5);
}

编译出来的 css 代码:

1
2
3
4
5
6
//CSS
.rgba {
color: rgba(255, 51, 102, 0.5);
background: rgba(255, 165, 0, 0.5);
border-color: rgba(0, 128, 0, 0.5);
}

RGB颜色函数-Red()、Green()、Blue()函数

Red() 函数

red() 函数非常简单,其主要用来获取一个颜色当中的红色值。假设有一个 #f36 的颜色,如果你想得到 #f36 中的 red 值是多少,这个时候使用 red() 函数就能很简单获取。

Green() 函数

green() 函数和 red() 函数一样,用来获取某一个颜色值中 green 的值。同样拿 ”#f36“ 颜色为例:

Blue() 函数

同理,blue() 函数是用来获取某一个颜色值中 blue 的值

RGB颜色函数-Mix()函数

Mix 函数是将两种颜色根据一定的比例混合在一起,生成另一种颜色。其使用语法如下:

1
mix($color-1,$color-2,$weight);

$color-1 和 $color-2 指的是你需要合并的颜色,颜色可以是任何表达式,也可以是颜色变量。

$weight 为 合并的比例(选择权重),默认值为 50%,其取值范围是 0~1 之间。它是每个 RGB 的百分比来衡量,当然透明度也会有一定的权重。默认的比例是 50%,这意味着两个颜色各占一半,如果指定的比例是 25%,这意味着第一个颜色所占比例为 25%,第二个颜色所占比例为75%。

HSL函数简介

  • hsl($hue,$saturation,$lightness):通过色相(hue)、饱和度(saturation)和亮度(lightness)的值创建一个颜色;
  • hsla($hue,$saturation,$lightness,$alpha):通过色相(hue)、饱和度(saturation)、亮度(lightness)和透明(alpha)的值创建一个颜色;
  • hue($color):从一个颜色中获取色相(hue)值;
  • saturation($color):从一个颜色中获取饱和度(saturation)值;
  • lightness($color):从一个颜色中获取亮度(lightness)值;
  • adjust-hue($color,$degrees):通过改变一个颜色的色相值,创建一个新的颜色;
  • lighten($color,$amount):通过改变颜色的亮度值,让颜色变亮,创建一个新的颜色;
  • darken($color,$amount):通过改变颜色的亮度值,让颜色变暗,创建一个新的颜色;
  • saturate($color,$amount):通过改变颜色的饱和度值,让颜色更饱和,从而创建一个新的颜色
  • desaturate($color,$amount):通过改变颜色的饱和度值,让颜色更少的饱和,从而创建出一个新的颜色;
  • grayscale($color):将一个颜色变成灰色,相当于desaturate($color,100%);
  • complement($color):返回一个补充色,相当于adjust-hue($color,180deg);
  • invert($color):反回一个反相色,红、绿、蓝色值倒过来,而透明度不变。

HSL函数-lighten()

来看一个简单的实例,首先定义一个颜色变量:
$baseColor: #ad141e;

使用 lighten() 和 darken() 函数来修改 10% 的亮度值:

1
2
3
4
5
6
7
//SCSS
.lighten {
background: lighten($baseColor,10%);
}
.darken{
background: darken($baseColor,10%);
}

编译出来的 css 代码:

1
2
3
4
5
6
7
8
//CSS
.lighten {
background: #db1926;
}

.darken {
background: #7f0f16;
}

HSL函数-saturate()

saturate()、desaturate()这两个函数是通过改变颜色的饱和度来得到一个新的颜色,他们和前面介绍的修改亮度得到新颜色的方法非常相似。

1
2
3
4
5
6
7
8
//SCSS
$baseColor: #ad141e;
.saturate {
background: saturate($baseColor,30%); //在原色饱和度基础上增加饱和度
}
.desaturate {
background: desaturate($baseColor,30%);//在原色饱和度基础上减少饱和度
}

编译出来的 css 代码:

1
2
3
4
5
6
7
8
//CSS
.saturate {
background: #c1000d;
}

.desaturate {
background: #903137;
}

HSL函数-adjust-hue()函数

这个是通过调整颜色的色相换算一个新颜色。他需要一个颜色和色相度数值。通常这个度数值是在 -360deg 至 360deg 之间,当然了可以是百分数:

1
2
3
4
5
6
7
8
//SCSS
$baseColor: #ad141e;
.adjust-hue-deg {
background: adjust-hue($baseColor,30deg);
}
.adjust-hue-per {
background: adjust-hue($baseColor,30%);
}

编译出的 css 代码:

1
2
3
4
5
6
7
8
//CSS
.adjust-hue-deg {
background: #ad5614;
}

.adjust-hue-per {
background: #ad5614;
}

HSL函数-grayscale()函数

这个函数会颜色的饱和度值直接调至 0%,所以此函数与 desaturate($color,100%) 所起的功能是一样的。一般这个函数能将彩色颜色转换成不同程度的灰色。

Opacity函数简介

  • alpha($color) /opacity($color):获取颜色透明度值;
  • rgba($color, $alpha):改变颜色的透明度值;
  • opacify($color, $amount) / fade-in($color, $amount):使颜色更不透明;
  • transparentize($color, $amount) / fade-out($color, $amount):使颜色更加透明。

Opacity函数-alpha()、opacity()函数

alphpa() 和 opacity() 函数很简单,与前面介绍的 red(),green() 等函数很类似。这个函数的主要功能是用来获取一个颜色的透明度值。如果颜色没有特别指定透明度,那么这两个函数得到的值都会是 1:

Opacity函数-opacify()、fade-in()函数

这两个函数是用来对已有颜色的透明度做一个加法运算,会让颜色更加不透明。其接受两个参数,第一个参数是原始颜色,第二个参数是你需要增加的透明度值,其取值范围主要是在 0~1 之间。当透明度值增加到大于 1 时,会以 1 计算,表示颜色不具有任何透明度。

其中 fade-in( ) 函数又名 fade_in() 函数。其所起作用等效。

Opacity函数-transparentize()、 fade-out()函数

transparentize() 和 fade-out() 函数所起作用刚好与 opacify() 和 fade-in() 函数相反,让颜色更加的透明。这两个函数会让透明值做减法运算,当计算出来的结果小于 0 时会以 0 计算,表示全透明。

19-sass中的@规则

发表于 2018-05-03 | 分类于 前端-07-scss

@import

Sass 扩展了 CSS 的 @import 规则,让它能够引入 SCSS 和 Sass 文件。 所有引入的 SCSS 和 Sass 文件都会被合并并输出一个单一的 CSS 文件。 另外,被导入的文件中所定义的变量或 mixins 都可以在主文件中使用。

Sass 会在当前目录下寻找其他 Sass 文件, 如果是 Rack、Rails 或 Merb 环境中则是 Sass 文件目录。 也可以通过 :load_paths 选项或者在命令行中使用 –load-path 选项来指定额外的搜索目录。

@import 根据文件名引入。 默认情况下,它会寻找 Sass 文件并直接引入, 但是,在少数几种情况下,它会被编译成 CSS 的 @import 规则:

  • 如果文件的扩展名是 .css。
  • 如果文件名以 http:// 开头。
  • 如果文件名是 url()。
  • 如果 @import 包含了任何媒体查询(media queries)。

如果上述情况都没有出现,并且扩展名是 .scss 或 .sass, 该名称的 Sass 或 SCSS 文件就会被引入。 如果没有扩展名, Sass 将试着找出具有 .scss 或 .sass 扩展名的同名文件并将其引入。

例如:

1
@import "foo.scss";

或

1
@import "foo";

两者都将引入 foo.scss 文件, 而

1
2
3
4
@import "foo.css";
@import "foo" screen;
@import "http://foo.com/bar";
@import url(foo);

将被编译为:

1
2
3
4
@import "foo.css";
@import "foo" screen;
@import "http://foo.com/bar";
@import url(foo);

也可以通过一个 @import 引入多个文件。例如:

1
@import "rounded-corners", "text-shadow";

将引入 rounded-corners 和 text-shadow 两个文件。

如果你有一个 SCSS 或 Sass 文件需要引入, 但是你又不希望它被编译为一个 CSS 文件, 这时,你就可以在文件名前面加一个下划线,就能避免被编译。 这将告诉 Sass 不要把它编译成 CSS 文件。 然后,你就可以像往常一样引入这个文件了,而且还可以省略掉文件名前面的下划线。

例如,你有一个文件叫做 _colors.scss。 这样就不会生成 _colors.css 文件了, 而且你还可以这样做:

1
@import "colors";//不用加下划线

来引入 _colors.scss 文件。

注意,在同一个目录不能同时存在带下划线和不带下划线的同名文件。 例如, _colors.scss 不能与 colors.scss 并存。

嵌套 @import

虽然大部分时间只需在顶层文件使用 @import 就行了, 但是,你还可以把他们包含在 CSS 规则 和 @media 规则中。

来看官网提供的一个简单示例:

假设要引入的样式文件example.scss文件中包含这样的代码:

1
2
3
.example {
color: red;
}

然后这样引用:

1
2
3
#main {
@import "example";
}

编译出来的 CSS:

1
2
3
#main .example {
color: red;
}

@media

Sass 中的 @media 指令和 CSS 的使用规则一样的简单,但它有另外一个功能,可以嵌套在 CSS 规则中。有点类似 JS 的冒泡功能一样,如果在样式中使用 @media 指令,它将冒泡到外面。来看一个简单示例:

1
2
3
4
5
6
.sidebar {
width: 300px;
@media screen and (orientation: landscape) {
width: 500px;
}
}

编译出来:

1
2
3
4
5
.sidebar {
width: 300px; }
@media screen and (orientation: landscape) {
.sidebar {
width: 500px; } }

@extend

Sass 中的 @extend 是用来扩展选择器或占位符。比如:

1
2
3
4
5
6
7
8
9
10
11
.error {
border: 1px #f00;
background-color: #fdd;
}
.error.intrusion {
background-image: url("/image/hacked.png");
}
.seriousError {
@extend .error;
border-width: 3px;
}

多个扩展

所设某个样式要继承多个地方的样式,那么可以使用 @extend 来继承多个选择器或占位符的样式,如:

1
2
3
4
5
6
7
8
9
10
11
12
13
.error {
border: 1px #f00;
background-color: #fdd;
}
.attention {
font-size: 3em;
background-color: #ff0;
}
.seriousError {
@extend .error;
@extend .attention;
border-width: 3px;
}

编译出来的CSS

1
2
3
4
5
6
7
8
9
10
.error, .seriousError {
border: 1px #f00;
background-color: #fdd; }

.attention, .seriousError {
font-size: 3em;
background-color: #ff0; }

.seriousError {
border-width: 3px; }

扩展单一选择器

前面我们知道 %placeholder 不使用@extend显示调用是不会生成任何样式代码。那么在选择器中使用占位符一样。比如下面的代码:

1
2
3
4
5
#context a%extreme {
color: blue;
font-weight: bold;
font-size: 2em;
}

这段代码在不调用之前不产生任何代码,只有能过@extend调用之后才生成代码:

1
2
3
.notice {
@extend %extreme;
}

编译出来的CSS

1
2
3
4
5
#context a.notice {
color: blue;
font-weight: bold;
font-size: 2em;
}

@at-root

@at-root 从字面上解释就是跳出根元素。当你选择器嵌套多层之后,想让某个选择器跳出,此时就可以使用 @at-root。来看一个简单的示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.a {
color: red;

.b {
color: orange;

.c {
color: yellow;

@at-root .d {
color: green;
}
}
}
}

编译出来的CSS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.a {
color: red;
}

.a .b {
color: orange;
}

.a .b .c {
color: yellow;
}

.d {
color: green;
}

@debug

@debug 在 Sass 中是用来调试的,当你的在 Sass 的源码中使用了 @debug 指令之后,Sass 代码在编译出错时,在命令终端会输出你设置的提示 Bug:

1
@debug 10em + 12em;

会输出:

1
Line 1 DEBUG: 22em

@warn

@warn 和 @debug 功能类似,用来帮助我们更好的调试 Sass。如:

1
2
3
4
5
6
7
8
9
10
11
@mixin adjust-location($x, $y) {
@if unitless($x) {
@warn "Assuming #{$x} to be in pixels";
$x: 1px * $x;
}
@if unitless($y) {
@warn "Assuming #{$y} to be in pixels";
$y: 1px * $y;
}
position: relative; left: $x; top: $y;
}

@error

@error 和 @warn、@debug 功能是如出一辙。

01-JQ复习

发表于 2018-05-03 | 分类于 前端-00-基础

轮播图


如果父级设定position:relative,子级设定position:absolute要设父级高度,否则高度撑不开;

jq on()方法


$(".div1").on('click', function(event) {
    // console.log($(this)[0].tagName);
    // console.log($(this).attr('class'));
    // $(this).html("hello");
    // event.preventDefault();
    console.log(event.target.tagName+" : "+$(event.target).attr('class')+" "+$(this).attr('class'));
    // $(this)指的是绑定事件的元素,也就是.div1
});

$(this)[0].tagName
如果委托的元素没有写出来,那么$(this)指的是 $(“.div1”),如果有写委托元素,那么$(this)指的是委托元素

jq的取值赋值


  • 当一组元素的时候,取值是一组中的第一个
  • 当一组元素的时候,赋值是一组中的所有元素

    $().text()是特例,会获取所有选中元素的文本内容,不包括html标签

return false;

阻止默认事件event.preventDefault(); 又阻止冒泡event.stopPropagation();

offset();

offset().left//获取到屏幕的左距离
position().left//自己转换为定位元素,忽略margin值

Parent() offsetParent();

Parent()//获取父级
offsetParent()//获取有定位的父级

screenX clientX pageX的区别

image

查看图片

outerWidth()与原生offsetWidth


//outerWidth():可以获取到隐藏元素的值
//offsetWidth : 是获取不到隐藏元素的值

clone()


clone(true)会把绑定到原来元素的事件也一并克隆.

包装


  • wrap() : 包装

  • wrapAll() : 整体包装

  • wrapInner() : 内部包装

  • unwrap() : 删除包装 ( 删除父级 : 不包括body )

表单序列化

1
2
3
4
5
6
7
8
9
//console.log($('form').serialize());  //string : a=1&b=2&c=3

console.log( $('form').serializeArray() );

[
{ name : 'a' , value : '1' },
{ name : 'b' , value : '2' },
{ name : 'c' , value : '3' }
]

stop()

  • $(‘#div1’).stop(); //默认 : 只会阻止当前运动

  • $(‘#div1’).stop(true); //阻止后续的运动

  • $(‘#div1’).stop(true,true); //可以立即停止到指定的目标点

  • $(‘#div1’).finish(); //立即停止到所有指定的目标点

jsonp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$.ajax({
url: "https://sp0.baidu.com/5a1Fazu8AA54nxGko9WTAnF6hhy/su",
type: 'get',//默认get,不用写也可以
dataType: 'jsonp',
jsonp: "cb",//传递给请求处理程序或页面的,用以获得jsonp回调函数名的参数名(默认为:callback)
// jsonpCallback:"baidu",//自定义的jsonp回调函数名称,默认为jQuery自动生成的随机函数名
data:{
// json:1,
wd:"a"
},
success:function (data) {
console.log(data);
}
});

插件

  • $.extend({}) //工具方法
  • $.fn.extend({})//$()方法

$.grep()

1
2
3
4
5
6
7
jQuery.grep( array, function [, invert ] )

$.grep( [0,1,2], function(n,i){
return n > 0;
});
//结果:
//[1, 2]

插件的几种参数用法:

  1. 传入json对象:
    1
    2
    3
    4
    $( ".selector" ).button({
    disabled: true,
    create: function( event, ui ) {}
    });

2.传入参数:

1
2
3
4
5
$( ".selector" ).button( "disable" );

var isDisabled = $( ".selector" ).button( "option", "disabled" );

$( ".selector" ).button( "option", "disabled", true );

3.事件绑定:

1
$( ".selector" ).on( "buttoncreate", function( event, ui ) {} );

index()

1
2
3
4
5
6
7
8
9
10
11
<ul> 
<li id="foo">foo</li>
<li id="bar">bar</li>
<li id="baz">baz</li>
</ul>

$('li').index(document.getElementById('bar')); //1,传递一个DOM对象,返回这个对象在原先集合中的索引位置
$('li').index($('#bar')); //1,传递一个jQuery对象
$('li').index($('li:gt(0)')); //1,传递一组jQuery对象,返回这个对象中第一个元素在原先集合中的索引位置
$('#bar').index('li'); //1,传递一个选择器,返回#bar在所有li中的做引位置
$('#bar').index(); //1,不传递参数,返回这个元素在同辈中的索引位置。

01-js基础复习

发表于 2018-05-03 | 分类于 前端-02-js基础复习

1 json注意点

1.1 json[“name”]相当于 json.name
1.2 for in json:
1
2
3
for(var attr in json){
json[attr] //这里中括号不用双引号""
}
1.3 for in 适用于数组
1
2
3
for(var i in attr){
attr[i]
}

2 数组

2.1 数组定义方式:
  • var arr=[];
  • var arr=new Array();

    new Array(4);//表示数组的长度为4;

    2.2 对象属性和方法

    Array | 对象属性
    —|—
    constructor |返回对创建此对象的数组函数的引用。
    length |设置或返回数组中元素的数目。
    prototype |使您有能力向对象添加属性和方法。

Array 对象方法
concat() 连接两个或更多的数组,并返回结果。
join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
pop() 删除并返回数组的最后一个元素
push() 向数组的末尾添加一个或更多元素,并返回新的长度。
reverse() 颠倒数组中元素的顺序。
shift() 删除并返回数组的第一个元素
slice() 从某个已有的数组返回选定的元素
sort() 对数组的元素进行排序
splice() 删除元素,并向数组添加新元素。
toSource() 返回该对象的源代码。
toString() 把数组转换为字符串,并返回结果。
toLocaleString() 把数组转换为本地数组,并返回结果。
unshift() 向数组的开头添加一个或更多元素,并返回新的长度。
valueOf() 返回数组对象的原始值
2.2 sort:
1
2
3
arr.sort(function(a,b){
return parseInt(a)-parseInt(b);
})

随机排序

1
2
3
4
5
6
7
var arr = [ 1,2,3,4,5,6,7,8 ];

arr.sort(function ( a, b ) {
return Math.random() - 0.5;
});

alert( arr );

2.3 随机数

Math.round(Math.random()*(y-x)+x)

01-引入方式

发表于 2018-05-03 | 分类于 前端-05-react
1. 引入方式:
1
2
3
4
5
6
7
8
9
10
11
新版本需要注意的地方:

1,js文件引用换成最新的
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/react/15.3.0/react.min.js"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/react/15.3.0/react-dom.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/babel-core/5.8.23/browser.min.js"></script>
2,
<script type="text/jsx"> 换成 <script type="text/babel">
3, var tipE = React.findDOMNode(this.refs.tip);
换成 var tipE = ReactDOM.findDOMNode(this.refs.tip);
4,React.render 换成 ReactDOM.render
2. 单独引入jsx

<script type="text/babel" src="src/helloworld.js"></script>

3.demo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Hello React!</title>
<script src="js/build/react.js"></script>
<script src="js/build/react-dom.js"></script>
<script src="js/build/browser.min.js"></script>
</head>
<body>
<div id="example"></div>
<script type="text/babel" src="js/16-demo.jsx"> </script>
</body>
</html>

02-React.Children

发表于 2018-05-03 | 分类于 前端-05-react

React.Children 是顶层API之一,为处理 this.props.childrenb 这个封闭的数据结构提供了有用的工具。

this.props 对象的属性与组件的属性一一对应,但是有一个例外,就是 this.props.children 属性。它表示组件的所有子节点。

1.React.Children.map
1
2
3
4
5
6
7
8
9
10
11
object React.Children.map(object children, function fn [, object context])

使用方法:
React.Children.map(this.props.children, function (child) {
return <li>{child}</li>;
})

其他方法
this.props.children.forEach(function (child) {
return <li>{child}</li>
})

在每一个直接子级(包含在 children 参数中的)上调用 fn 函数,此函数中的 this 指向 上下文。如果 children 是一个内嵌的对象或者数组,它将被遍历:不会传入容器对象到 fn 中。如果 children 参数是 null 或者 undefined,那么返回 null 或者 undefined 而不是一个空对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<script type="text/jsx">
var NotesList = React.createClass({
render: function() {
return (
<ol>
{
React.Children.map(this.props.children, function (child) {
return <li>{child}</li>;
})
}
</ol>
);
}
});

React.render(
<NotesList>
<span>hello</span>
<span>hello</span>
</NotesList>,
document.body
);
</script>

这里需要注意, this.props.children 的值有三种可能:如果当前组件没有子节点,它就是 undefined ;如果有一个子节点,数据类型是 object ;如果有多个子节点,数据类型就是 array 。所以,处理 this.props.children 的时候要小心。
React 提供一个工具方法 React.Children来处理 this.props.children 。我们可以用 React.Children.map 来遍历子节点,而不用担心 this.props.children 的数据类型是 undefined 还是 object。

传入如下ReactElement:

1
2
3
4
5
6
7
8
9
10
11
12
13
<NotesList>
<span>hello</span>
<span>hello</span>
</NotesList>
//返回两个子节点


<NotesList></NotesList>
//返回undefined


<NotesList>null</NotesList>
//返回null
2、React.Children.forEach

React.Children.forEach(object children, function fn [, object context])

类似于 React.Children.map(),但是不返回对象。

3、React.Children.count

number React.Children.count(object children)

返回 children 当中的组件总数,和传递给 map 或者 forEach 的回调函数的调用次数一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
render: function() {
console.log(React.Children.count(this.props.children)); //2

return (
<ol>
{
this.props.children.forEach(function (child) {
return <li>{child}</li>
})
}
</ol>
);
}

不同的ReactElement,输出count值:

1
2
3
4
5
6
7
8
9
10
11
<NotesList>
<span>hello</span>
<span>hello</span>
</NotesList>
console.log(React.Children.count(this.props.children)); //2

<NotesList></NotesList>
console.log(React.Children.count(this.props.children)); //0

<NotesList>null</NotesList>
console.log(React.Children.count(this.props.children)); //1
4、React.Children.only

object React.Children.only(object children)

返回 children 中 仅有的子级。否则抛出异常。

1
2
console.log(React.Children.only(this.props.children[0])); 
//输出对象this.props.children[0]

02-js模式

发表于 2018-05-03 | 分类于 前端-00-基础

01-工厂模式

1
2
3
4
5
6
7
8
9
10
11
12
13
function CreatePerson(name){

this.name = name;
this.showName = function(){
alert( this.name );
};

}

var p1 = new CreatePerson('小明');
//p1.showName();
var p2 = new CreatePerson('小强');
//p2.showName();
  • 当new去调用一个函数: 这个时候函数中的this就是创建出来的对象,而且函数的的返回值直接就是this啦(隐式返回)
  • new后面调用的函数 : 叫做构造函数

01.01-对象的引用

  1. ==基本类型== : 赋值的时候只是值的复制
  2. ==对象类型== : 赋值不仅是值的复制,而且也是引用的传递

01.02-对象的比较

  1. ==基本类型== : 值相同就可以
  2. ==对象类型== : 对象类型 : 值和引用都相同才行

02-工厂模式之原型

1
2
3
4
5
6
7
8
function 构造函数(){
this.属性
}

构造函数.原型.方法 = function(){};

var 对象1 = new 构造函数();
对象1.方法();
  1. 先变型:
  2. 尽量不要出现函数嵌套函数
  3. 可以有全局变量
  4. 把onload中不是赋值的语句放到单独函数中

改成面向对象:

  1. 全局变量就是属性
  2. 函数就是方法
  3. Onload中创建对象
  4. 改this指向问题 : 事件或者是定时器,尽量让面向对象中的this指向对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
window.onload = function(){

var t1 = new Tab();
t1.init();

};

function Tab(){
this.oParent = document.getElementById('div1');
this.aInput = this.oParent.getElementsByTagName('input');
this.aDiv = this.oParent.getElementsByTagName('div');
}

Tab.prototype.init = function(){
var This = this;
for(var i=0;i<this.aInput.length;i++){
this.aInput[i].index = i;
this.aInput[i].onclick = function(){
This.change(this);
};
}
};

Tab.prototype.change = function(obj){
for(var i=0;i<this.aInput.length;i++){
this.aInput[i].className = '';
this.aDiv[i].style.display = 'none';
}
obj.className = 'active';
this.aDiv[obj.index].style.display = 'block';
};

02-产生不重复的随机数

发表于 2018-05-03 | 分类于 前端-02-js基础复习

1.

生成第i个[min,max]区间的随机数,并与之前i-1个数比较,如有重复,令i=i-1;重复生成第i个随机数。

1
2
3
4
5
6
7
8
9
10
11
12
13
function my_ran2(n,min,max){
var arr=[];
for(i=0;i<n;i++){
arr[i]=parseInt(Math.random()*(max-min+1)+min);
for(j=0;j<i;j++){
if(arr[i]==arr[j]){
i=i-1;
break;
}
}
}
return arr;
}

03-BOM

发表于 2018-05-03 | 分类于 前端-02-js基础复习

窗口

1

可视区尺寸:alert( document.documentElement.clientHeight );

窗口内容高度:document.body.offsetHeight

document.body是DOM中Document对象里的body节点, document.documentElement是文档对象根节点(html)的引用。

1…192021…33
静修

静修

322 日志
19 分类
19 标签
© 2019 静修
本站访客数:
由 Hexo 强力驱动
主题 - NexT.Pisces