精华内容
下载资源
问答
  • 009_css预处理器less sass saml sso 单点登录 websocket ## less 安装: npm install -g less 命令: lessc style.less style.css > 注意: .rect( 123, 456, 789){} 括号中是‘,’逗号,不能用“;” 分号...
    009_css预处理器less  sass  saml sso 单点登录  websocket
    
    ##   less
    
    安装: npm install -g less
    命令: lessc style.less style.css
    
    > 注意: .rect( 123, 456, 789){}  括号中是‘,’逗号,不能用“;” 分号
    
    1LESS是基于JavaScript运行,所以LESS是在客户端处理;Sass是基于Ruby的,是在服务器端处理的.
    2sass支持老的语法,可以不包含花括号和分号
    3sass的变量必须是$开始,然后变量名和值使用冒号隔开,跟css的属性一致
    4sass:  @include引入    less:   .class 引入
    
    变量、嵌套、mixin(混合)、继承、导入(import)、颜色函数、
    
    
    混合方法不一样,
    sass@mixin error($borderWidth: 2px) {
      border: $borderWidth solid #F00;
      color: #F00;
    }
    
    less.error(@borderWidth: 2px) {
      border: @borderWidth solid #F00;
      color: #F00;
    }
    
    
    .rect(@width1:100px,@height1:100px) {
      width: @width1;
      height: @height1;
    }
    
    
    定义变量:
    @base: #ff6700;
    .centerss{
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      margin: auto;
    }
    
    
    调用:
    div {
        .centerss();
    }
    
    css预处理器
    
    ## 区别
    http://www.cnblogs.com/wangpenghui522/p/5467560.html
    
    1.编译环境不一样
    
    Sass的安装需要Ruby环境,是在服务端处理的,而Less是需要引入less.js来处理Less代码输出css到浏览器,也可以在开发环节使用Less,然后编译成css文件,
    直接放到项目中,也有 Less.appSimpleLessCodeKit.app这样的工具,也有在线编译地址。
    
    2.变量符不一样,Less@,而Scss$,而且变量的作用域也不一样。
    
    3.Sass支持条件语句,可以使用if{}else{},for{}循环等等。而Less不支持。
    
        
    
    ##   SASS  
    
    . Sass简介
    Sass 是一种css预处理器,CSS 预处理器定义了一种新的语言,其基本思想是,用一种专门的编程语言,为 CSS 增加了一些编程的特性,将 CSS 作为目标生成文件,然后开发者就只要使用这种语言进行编码工作。
    
    
    /*
    
    变量默认只能在属性值中使用
    
    差值:
    选址器和属性部分用差值 #{$s}
    
    */
       $a:13;
       $a:12 !default;  //默认
       @debug $a;
       $aa: 10rem;
       $b: 10px;
       $c: null;
       @debug $aa;
       @debug $b;
       @debug $c;
       $d: $a * 2;
       $border: '1px solid black';
       @debug $d;
       @if ($a > 7){
       
       }
    
    
    
       npm install -g node-sass  安装node-sass的软件     node-sass -v
        npm install -g cnpm  //中文版 npm
        命令改为:
        cnpm install -g node-sass
    
    任何一个文件中都有 两个文件夹  .    ..
            .  当前文件夹
            .. 上一层
    
    cmd中复制命令:右键--标记--回车   C:\Users\Administrator\AppData\Roaming\npm
        把文件拖过去
    
        node-sass -w index.scss index.css
        node-sass -w index.scss index.css --output-style expanded
    
    
    
    ###    占位符 %      生成高效率群组选择器
       %  继承的方法   --> 群组选择器
    
    ###    扩展/继承(@extend)
    
    %mt5 {
        margin-top: 5px;
    }
    %pt5{
       padding-top: 5px;
    }
    
    .btn {
       @extend %mt5;
       @extend %pt5;
    }
    
    ###  for 循环
    @for $i from 1 through $num{
            #{$box}:nth-child(#{$i}){
                animation: drop 1s cubic-bezier(0.38, 1.48, 0.22, 1.32) ( $i - 1 ) * 0.1s both;
            }
        }
    
    
    ###    each 遍历
    $arr: 'one','two','three';
    @each $v in $arr{
        .atem-#{$v}{
            color:red;
        }
    }
    
    /*html中遍历:
    foreach($data as $v){
    
    }*/
       
        
    
    ##  单点登录    saml sso
    
    基于SAML的单点登录介绍
    http://blog.csdn.net/csethcrm/article/details/20694993
    
    单点登录SSOcookieticket)实现
    http://blog.csdn.net/z1729734271/article/details/52425746
    
    基于 SAML WebSphere Application Server 单点登录的场景设计
    https://www.ibm.com/developerworks/cn/websphere/library/techarticles/1012_zhangt_saml/1012_zhangt_saml.html
    
    
      **SAML 作用**
    SAML 主要包括三个方面:
    1.认证申明。表明用户是否已经认证,通常用于单点登录。
    2.属性申明。表明 某个Subject 的属性。
    3.授权申明。表明 某个资源的权限。
    
    它是一个基于XML的标准,用于 **在不同的安全域(security domain)之间交换认证和授权数据**
    SAML Assertions 断言:定义交互的数据格式 (XML)
    SAML Protocols 协议:定义交互的消息格式 (XML+processing rules)            ** [请求--响应协议] **
    SAML Bindings 绑定:定义如何与常见的通信协议绑定 (HTTP,SOAP)
    SAML Profile 使用框架:给出对 SAML 断言及协议如何使用的建议 (Protocols+Bindings)
    
    >  SAML 协议标准中出现的两个角色,
            一个是 Identity Provider(IdP)【身份提供者, 身份提供商】,通常 IdP 负责创建、维护和管理用户认证。
            一个是 Service Provider(SP)【服务提供者, 服务提供者】,通常 SP 控制用户是否能够使用该 SP 提供的服务和资源。
            
    登录成功后,系统会自动给你的浏览器设置cookie,证明你已经登录过了。
    当你再访问这个应用的需要保护的URL的时候,系统还是要进行安全检查的,但是这次系统能够发现相应的cookie
    
    上图就是一个利用cookie做单点登录的原理图,案例为用户dgh(密码123)登录www.qiandu.com,之后又登录mail.qiandu.com。流程如下:
      第一步:用户输入用户名/密码(dgh/123)登录到www.qiandu.com  第二步:www.qiandu.com处理登录逻辑,并且将用户信息通过cookie的方式返回到客户端(最好加密用户信息)。
      第三步:用户访问mail.qiandu.com,浏览器自动将用户信息携带到mail.qiandu.com,通过过滤器(filter)处理用户的登录请求。
      第四步:过滤器从cookie中获取用户信息,登录,返回用户访问界面。这样用户就只登录一次,就访问了两个网站了。
    
        
    1. user访问应用服务
    2. [点登录]WEB APP1 生成SAML请求  -->
    3. 定向到浏览器访问SSO URL -->
    4. [login get'/sso'] 统一认证中心    解析SAML请求,需提供有效登陆凭证或cookie信息进行认证。 -->
            跳转到登录页面 输入ID password    -->
    5. [callback.js post'/sso'] 进行认证,认证成功,以cookie方式存储用户相关信息,构造断言,生成SAML响应。  -->
    6. 编码后的响应定向到浏览器访问ACS
    7. WEB APP1 使用IDP的公钥验证SAML响应。验证成功,登录app
    
    
    ## shell 
    同时它又是一种程序设计语言。作为命令语言,它交互式解释和执行用户输入的命令或者自动地解释和执行预先设定好的一连串的命令;
    作为程序设计语言,它定义了各种变量和参数,并提供了许多在高级语言中才具有的控制结构,包括循环和分支。
    
    文字操作系统与外部最主要的接口就叫做shellshell是操作系统最外面的一层。shell管理你与操作系统之间的交互:等待你输入,
    向操作系统解释你的输入,并且处理各种各样的操作系统的输出结果。
    
    
    
    
    
    ##  websocket socket.io
    Websocket是什么?
    
    Websocket是一种协议,它本质上是一个基于TCP的协议,它由通信协议和编程API组成,WebSocket能够在浏览器和服务器之间建立双向连接, 
    以基于事件的方式,赋予浏览器实时通信能力。既然是双向通信,就意味着服务器端和客户端可以同时发送并响应请求,而不再像HTTP的请求和响应。
    
    为了建立一个WebSocket连接,客户端浏览器首先要向服务器发起一个HTTP请求,这个请求和通常的HTTP请求不同,包含了一些附加头信息,
    其中附加头信息”Upgrade: WebSocket”表明这是一个申请协议升级的HTTP请求,服务器端解析这些附加的头信息然后产生应答信息返回给客户端,
    客户端和服务器端的 WebSocket连接就建立起来了,双方就可以通过这个连接通道自由的传递信息,并且这个连接会持续存在直到客户端或者服务器端的
    某一方主动的关闭连接
    
    websocket的产生背景
    
    Websocket出现之前,浏览器与服务器之间通过http只能实现单向的通信。在此之前,要实现浏览器之间的即时通信,一般采用Comet来模拟。
    Comet是一种服务器向页面推送消息的技术,这种技术可以让信息实时推送到页面,也算是可以比较完整地实现实时通信,但是效率低下。
    实现Comet的方式主要有两种,一种是轮询(polling),一种是流。
    轮询,就是客户端通过一定的时间间隔以频繁请求的方式向服务器发送请求,来保持客户端和服务器端的数据同步。问题很明显,当客户端以固定频率向服
    务器端发送请求时,服务器端的数据可能并没有更新,带来很多无谓请求,浪费带宽,效率低下。
    第二种实现Comet的是HTTP流。流不同于轮询,它在页面的整个生命周期内只使用一个HTTP连接,通过服务器端语言的缓冲区刷新机制来将消息推送出去。
    
    除了Comet,通过FlashAPI也是可以实现Socket的。AdobeFlash 通过自己的 Socket 实现完成数据交换,再利用 Flash 暴露出相应的接口为 
    JavaScript 调用,从而达到实时传输目的。此方式比轮询要高效,但是随着今年Flash正式宣告退出历史舞台,这种方式现在的存在意义不大。
    由此看出,传统 Web 模式在处理高并发及实时性需求的时候,会遇到难以逾越的瓶颈,我们需要一种高效节能的双向通信机制来保证数据的实时传输。
    在此背景下,基于 HTML5 规范的、有 Web TCP 之称的 WebSocket 应运而生。
    
    
    websocket的实现原理
    
    在实现websocket连线过程中,需要通过浏览器发出websocket连线请求,然后服务器发出回应,这个过程通常称为握手。在 WebSocket API浏览器和服务器只需要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。
    
    
    ###  Socket.io模块
    
    Socket.io是基于Nodejs生态的,但是做Nodejs所不能实现的WebSocket的库。就像Express之于NodejsjQuery之于Javascript***Socket.io是对Node语言关于WebSocket所有API的封装和拓展,是一个应用框架。***
    
    Socket.IO是一个开源的WebSocket库,它通过Node.js实现WebSocket服务端,同时也提供客户端JS库。Socket.IO支持以事件为基础的实时双向通讯,
    它可以工作在任何平台、浏览器或移动设备。
    
    Socket.IO支持4种协议:WebSockethtmlfilexhr-pollingjsonp-polling,它会自动根据浏览 器选择适合的通讯方式,
    从而让开发者可以聚焦到功能的实现而不是平台的兼容性,同时Socket.IO具有不错的稳定性和性能。
    Socket.io的作用主要是将webSocket协议应用到所有的浏览器。该模块主要应用于实时的长连接多请求项目中,
    例如在线联网游戏、实时聊天、实时股票查看、二维码扫描登录等。
    Socket协议存在服务端和客户端,因此要实现一个socket服务时,根据socket的服务端和客户端API分别实现其逻辑。服务端启动进程等待客户端的连接。
    
    
    > Socket.io基本使用方法:
    
    1】服务端:
    npm install socket.io 安装socket.io
    
    var io=require('socket.io').listen(8081);
    或者: 
    var app = require('express')();
    var server = require('http').Server(app);
    var io = require('socket.io')(server);
    
    2】服务端:
    io.on(‘connection’,function(socket));//监听客户端连接,回调函数会传递本次连接的socket
    socket.on(‘String’,function(data));//监听客户端发送的信息
    例子:
    socket.on('my other event',function(data){
       console.log(data);
    });
    socket.emit(‘String’, data);//给该socket的客户端发送消息
    socket.emit('news',{hello:'world'});
    
     socket.on('disconnect', function () {//断开连接
        io.emit('user disconnected');
      });
    
    
    3】服务端:
    io.sockets.emit(‘String’,data);//给所有客户端广播消息
    io.sockets.socket(socketid).emit(‘String’, data);//给指定的客户端发送消息
    广播消息:
    //给除了自己以外的客户端广播消息
    socket.broadcast.emit("msg",{data:"hello,everyone"}); 
    //给所有客户端广播消息
    io.sockets.emit("msg",{data:"hello,all"});
    分组
    socket.join(room1);//加入room1分组;
    socket.leave(room1);//退出分组
    对分组中的用户发送信息
    socket.broadcast.to('group1').emit('event_name', data);//不包括自己
    io.sockets.in('group1').emit('event_name', data);//包括自己
    broadcast方法允许当前socket client不在该分组内
    
    4】客户端:
    引入js<script src="js/socket.io.js"></script>
    <script>
    var socket=io.connect('http://localhost:8081');//连接服务器
    socket.on('news',function(data){
       console.log(data);
       socket.emit('my other event',{clinetMessage:'client data'});
    });
    </script>
    
    5】客户端:
    客户端socket.on()监听的事件:
    connect:连接成功
    connecting:正在连接
    disconnect:断开连接
    connect_failed:连接失败
    error:错误发生,并且无法被其他事件类型所处理
    message:同服务器端message事件
    anything:同服务器端anything事件
    reconnect_failed:重连失败
    reconnect:成功重连
    reconnecting:正在重连
    当第一次连接时,事件触发顺序为:connecting->connect;当失去连接时,事件触发顺序为:disconnect->reconnecting(可能进行多次)->connecting->reconnect->connect
    
    
    
    展开全文
  • 什么是CSS预处理器Css可以让你做很多事情,但它毕竟是给浏览器认的东西,对开发者来说,Css缺乏很多特性,例如变量、常量以及一些编程...目前比较流行的两种预处理器SassLess。至于他们谁更优秀一些:简短的答
  • CSS 预处理器: Sass/Scss & Less 文章目录CSS 预处理器: Sass/Scss & Less前言Why 预处理器Sass?Scss?正文1. 预处理器的编译工具Less 编译Sass/Scss 编译2. Gulp 实现自动化编译3. 预处理器功能3.0 ...

    CSS 预处理器: Sass/Scss & Less

    前言

    CSS 层叠样式表作为 HTML 的极大增强功能,使得空洞简陋的 html 页面套用丰富的样式规则和页面特效,然而我们今天要来介绍的是 CSS 预处理器(Preprocessor)。

    Why 预处理器?

    为什么需要预处理器呢?写过一点 CSS 的前端朋友常常会在开发业务的时候遇到一些情况:需要使用精确的选择器来定位元素、常常写重复的样式逻辑、想要使用优先级来覆盖一些原有样式而刻意增加选择器权重、… 等。以上逻辑有时候不能说不好,也都是一些正规可接受的解决方案,但是问题在于:太麻烦了!

    为了一些基本的业务逻辑而陷于 CSS 语法的泥沼,不断编写重复的 CSS 代码如下:

    .header > .title > .left > .inner > .a {/* ... */}
    .header > .title > .left > .inner > .b {/* ... */}
    .header > .title > .left > .inner > .c {/* ... */}
    

    是不是看了就觉得烦,但是没办法,这就是 CSS。

    所以我们就可以使用 CSS 预处理器,提供开发者更强大的语法支持,并透过工具自动转换成浏览器能识别的基本 CSS 语法,用了预处理器之后上述语法可以变为:

    .header {
        > .title {
            > .left {
                > .inner {
                    > .a {/* ... */}
                    > .b {/* ... */}
                    > .c {/* ... */}
                }
            }
        }
    }
    

    这样看起来是不是舒服多了,而且当我们需要在不同层级增加扩展的时候就特别方便了。

    下面我们将要来介绍 Sass 和 Less 两种最有名的 CSS 预处理器。

    Sass?Scss?

    Sass 是包名称,编写语法风格使用缩进代替原生 CSS 的大括号;Scss 是使用 css 代码风格(大括号)的 Sass,通常还是用后者(也不知道作者怎么想的,可能就对缩进的样式情有独钟,进而斗胆破坏 CSS 的编码风格,这不找麻烦吗hhh)

    正文

    Sass 和 Less 的特性啊还是一些官方描述、宣传句子就不说了,简单来说都是一种 CSS 的增强语法。

    1. 预处理器的编译工具

    说白了,预处理器就是在真实使用 CSS 前经过一次编译的过程,将增强的语法功能转换回原生的 CSS 语法。所以,第一步我们要先来了解 Sass 和 Less 到底该怎么编译

    Less 编译

    先来说比较单纯的 less。Less.js 本来就是采用 js 实现的预处理器,所以想当然他就是一个基本的 node 包,所以我们可以直接使用 npm/yarn 包管理工具来下载并使用:

    $ yarn add less -D
    $ yarn lessc <source-file> <target-file>
    

    less 编译的核心命令为 lessc,传入源文件路径和目标文件名/路径就行了。另外需要注意按惯例 less 的语法需要写在 .less 扩展名的文件下,这也很好理解

    Sass/Scss 编译

    1. Ruby 版本:Sass 比较特别的是使用 Ruby 实现的编译器(可能是当时最潮的 web 领域用的编程脚本吧,在 Node 出生之前),所以要使用最原本的 Sass 编译器还要下一个 Ruby。

    2. node-sass / dart-sass:第二种方案是使用 Node 环境下的 Sass,可能依据情况还要依赖底层 libsass(我是用 mac 自带 ruby 所以没啥问题,windows 用户可能会出现 node-sass 不能用,那就用 dart-sass 吧)

    $ yarn add node-sass
    $ yarn node-sass <source-file> <target-file>
    

    编译选项也差不多,就是源文件跟目标文件

    2. Gulp 实现自动化编译

    再再配置一下,待会要用到好多文件能,总不能一个个手动编译吧。这边用上 gulp 简单构建一个自动编译的配置,在根目录下创建 gulpfile.js

    • gulpfile.js
    const gulp = require('gulp')
    const less = require('gulp-less')
    const sass = require('gulp-sass')
    
    const tasks = [
      {
        name: 'less',
        src: 'src/less/*.less',
        plugin: less,
        option: {},
        dest: 'lib/less',
      },
      {
        name: 'scss',
        src: 'src/scss/*.scss',
        plugin: sass,
        option: { outputStyle: 'expanded' },
        dest: 'lib/scss',
      },
    ]
    
    tasks.forEach(({ name, src, plugin, option, dest }) => {
      gulp.task(name, (done) => {
        gulp.src(src).pipe(plugin(option)).pipe(gulp.dest(dest))
        done()
      })
    })
    
    gulp.task('default', gulp.parallel(...tasks.map((task) => task.name)))
    
    gulp.task('watch', (done) => {
      tasks.forEach(({ name, src }) => {
        console.log(`watch '${src}' and do '${name}'`)
        gulp.watch(src, gulp.task(name))
      })
      done()
    })
    

    简单来说我们配置了:

    • 一个 less 任务用于编译 /src/less 目录下的所有 .less 文件到 /lib/less 目录下
    • 一个 scss 任务用于编译 /src/scss 目录下的所有 .scss 文件到 /lib/scss 目录下
    • 一个 default 默认任务并行执行 lessscss 两个任务
    • 一个 watch 任务用于监听文件变化,实时执行 lessscss 两个任务

    这边 gulp 不是重点,就是方便测试,下面马上进入正题

    3. 预处理器功能

    3.0 预处理器功能概述

    这边列出我们接下来要介绍的预处理器能力:

    • 变量(Variables)
    • 嵌套(Nesting)
    • 混合(Mixins)
    • 继承(Extensions)
    • 运算(Operations) & 函数(Functions)
    • 控制指令(Control Directives)
    • 注释(Comments)
    • 导入(Importing)

    ,可以说是不管在 Less 还是 Sass 都存在自己的实现方式,实现的模式也是大同小异,所以用哪个其实都差不多,看个人喜好。好了不bb了,马上来看看 CSS 预处理器的强大之处。

    3.1 变量(Variables)

    首先第一个特性是解决 CSS 最让人诟病的一个问题:变量的复用。

    常常我们需要在好多地方复用同一个颜色或是固定的颜色风格,或是在不同样式之间维护相同的属性值。在原生 CSS 的规则之下我们只能手动的维护,到了 CSS3 才能够使用 --var + var() 的组合招来实现,然而预处理器早就实现了这个功能,甚至比原生的都要灵活:

    • Less 使用 @ 符号声明变量
    • Sass/Scss 使用 $ 符号声明变量

    3.1.1 基本使用

    预处理器中,变量可以替换为 属性值属性名选择器,分别都有不同的写法

    3.2 嵌套(Nesting)

    第二项能力就是在前言中提到的,将丑陋的多层选择器转换为嵌套的形式。这个特性的实现 Less 和 Sass 的几乎一致,就是将样式表放到外层选择器样式表之中,进行 嵌套定义

    3.2.1 基本使用

    第一种是基本的使用姿态,直接嵌套、使用 >+[space] 关键字来表达不同的 CSS 组选择器,语法和效果如下

    3.2.2 父选择器

    比较特别的是,默认的嵌套行为是使用 A B 的祖先-子代选择器,而且必定是外层选择器作为前导,如果我们想要复用外层选择器或是改变选择器次序则可以使用 & 符号替代外层选择器:

    3.3 混合(Mixins)

    第三种能力是混合,也就是我们最需要的样式复用。我们知道 CSS 本身就是透过选择器的方式对不同的元素应用样式表来完成复用,然而该方式的粒度还是略显繁杂,衍生出 原子 CSS 的实现思想。但是在预处理器的能力之下我们就能够轻松的透过 混合(Mixins) 来完成样式的复用

    3.3.1 基本使用

    第一种是混合的基本使用:

    • Less 直接将样式写在别的样式里面就有了
    • Sass/Scss 需要使用 @mixin + @include 关键字来实现

    3.3.2 带参数的混合器

    更进一步,我们可以透过传递参数的方式来特制需要混入的样式,两者的实现方式非常相似,就是在混合器的选择器/名称后面加上形式参数列表(还可以使用默认参数):

    3.3.3 不输出混合器

    Sass/Scss 默认混合器就是一个特别的样式,不用 @include 不会出现;然而 Less 却是能将一般的样式也作为混合器混入其他样式,所以我们可以在样式后面加上空参数列表 selector() 来声明为一个纯混合器而不会直接放到编译后结果之中。

    3.4 继承(Extensions)

    继承的复用形式又与混合不太一样:

    • 混合:将 A 的样式混合到 B 的样式当中
    • 继承:A 继承 B 的意思就是,对于所有套用 B 的样式表 A 也应该套用,也就是会将继承其他类的选择器添加到继承目标的所有样式表选择器上

    3.4.1 基本使用

    基本的使用方式:

    • Less 使用 :extend(father) 伪类来引入继承的特性
    • Sass/Scss 则使用 @extend 关键字来实现继承

    3.4.2 纯虚样式

    跟 C++ 的纯虚函数或是 Java 的接口相似,我们希望父类只是一个抽象,不会直接出现在编译结果当中,Sass/Scss 提供 % 符号作为类的前缀,可以表示一个纯虚样式表的实现,只有当被继承的时候才会引入

    3.5 运算(Operations) & 函数(Functions)

    接下来一个很重要的能力时运算和函数的能力。原生 CSS 提供的函数和运算方法寥寥无几(可以说就只有 calc 一个),预处理器提供了我们更多的运算空间,同时提供了大量的内置函数和自定义函数的能力。

    不过需要注意的是即便看起来是根据变量来运算,但其实一切都会在编译后消失,所以真正最后编译的样式结果其实还是静态的,只是更方便开发者定义变量值运算逻辑和确定计算过程而已。

    3.5.1 基本使用

    基本的运算方法可以分为:

    • 数字运算
    • 字符串运算
    • 颜色创建/颜色修改
    • 其他内置函数

    详细的内置函数扩展可以查询各预处理器官网 API 说明

    3.5.2 自定义函数

    虽然两者都提供了一些基本运算方法和内置函数,有时候我们还是想要定义自己的函数,预处理器就厉害了,为 CSS 加入了类似命令式编程的语法,编译原理就是这么强大,这都能转:

    • Less 使用 Mixins + Maps 的组合来模拟实现函数的效果
    • Sass/Scss 提供 @function + @return 的关键字来实现更平易近人的函数调用体验

    3.6 控制指令(Control Directives)

    快进入到尾声了,预处理器还提供了类似条件判断、循环等控制语句的模拟实现,逻辑判断和大量生成也是难不倒预处理器的

    3.6.1 条件分支 if

    两种预处理器都提供了条件分支的 if 实现:

    • Less 使用 if(condition, true-result, false-result) 内置方法实现
    • Sass/Scss 则使用 @if 关键字进行条件编译

    3.6.2 列表遍历 each

    在一般的 for 循环之前,我们先说说遍历既有列表的 each 方法:

    • Less 使用 each(list, stylesheet) 方法实现,样式表内部使用 @value 来拿到每次遍历的值
    • Sass/Scss 使用 @each var in list 的方法实现

    3.6.3 循环遍历 for

    • Less 使用了 each + range 的组合来模拟实现 for 循环的效果
    • Sass/Scss 使用 @for var from a through b 的关键字实现

    3.7 注释(Comments)

    CSS 注释倒是比较简单,原生 CSS 只存在 /* */ 多行注释的形式,预处理器虽然允许 // 单行注释,但是会在编译后将其省略

    3.8 导入(Importing)

    最后一个就是导入外部样式表的能力,原生 CSS 也提供 @import 的语法,所以这边其实也差不多

    4. 附录:webpack 打包编译嵌入

    在正式业务流程中不会想再自己一个个编译打包,通常会选择一个自动化打包工具来使用,这边以 webpack 为例:

    对于 webpack 来说一切模块皆 js,所以 .less.scss 这种不伦不类的扩展不认识,就要用特定的 loader 进行编译后转化为标准 js 嵌入

    4.1 下载依赖

    首先是编译选项的依赖,webpack 核心的就不列了

    • Less 编译工具 & loader
    $ yarn add less less-loader -D
    
    • Sass/Scss 编译工具 & loader
    $ yarn add node-sass sass-loader -D
    

    如同前面提过的 node-sass 用不了就用 dart-sass 吧,别死磕了

    4.2 配置文件

    主要就是配置 loader,在 module.rules 下添加规则:

    • webpack.config.js
    module.exports = {
      // ...
      module: {
        rules: [
          // ...
          {
            test: /\.less$/,
            use: ['style-loader', 'css-loader', 'less-loader'],
          },
          {
            test: /\.scss$/,
            use: ['style-loader', 'css-loader', 'sass-loader'],
          },
          // ...
        ],
      },
      // ...
    }
    

    简单来说就是使用 less-loader/sass-loader.less/.scss 文件转换为普通 CSS 之后就能够套用 css-loaderstyle-loader 转化为正常模块了

    结语

    CSS 预处理为开发者剩下大把的代码维护成本,同时也提高代码的可读性以及可维护性。Less 和 Sass 的使用上也基本差不多,学好一个要再转也是很快的,本篇供大家参考,欢迎指教。

    其他资源

    参考连接

    Less 官方-中文 https://less.bootcss.com/
    Sass 官网 https://sass-lang.com/
    Sass 中文网 https://www.sass.hk/
    Gulp 中文网 https://v3.gulpjs.com.cn/
    用gulp如何编译多个文件夹下的less https://segmentfault.com/q/1010000009691680
    使用gulp编译sass https://www.cnblogs.com/wuzhiquan/p/6738018.html
    SASS学习系列之三--------- node-sass 自动编译scss 文件 https://blog.csdn.net/wx11408115/article/details/78032443
    串行方式运行任务,亦即,任务依赖 https://v3.gulpjs.com.cn/docs/recipes/running-tasks-in-series/
    gulp构建项目(三):gulp-watch监听文件改变、新增、删除 https://blog.csdn.net/guang_s/article/details/84672449
    Webpack安装(2)-打包css、scss、less(包括编译、分离) https://blog.csdn.net/lhtzbj12/article/details/79188447
    webpack---less+热更新 使用 https://www.cnblogs.com/chen-cong/p/8323958.html

    完整代码实现

    https://github.com/superfreeeee/Blog-code/tree/main/front_end/css/css_sass_less

    展开全文
  • 一、CSS 预处理器 CSS 预处理器是一种脚本语言,用一种专门的编程语言来进行 Web 页面样式设计...SassLess 就是两种常见的 CSS 预处理器,我们可以把 SassLess 编辑的样式转换为正常的 CSS样式。他们引入了...

    一、CSS 预处理器

    CSS 预处理器是一种脚本语言,用一种专门的编程语言来进行 Web 页面样式设计,然后再转换为正常的 CSS 样式,进而实现构建动态 CSS 样式。

    CSS 预处理器为 CSS 增加了一些编程的特性,无需考虑浏览器的兼容性问题。

    Sass 和 Less 就是两种常见的 CSS 预处理器,我们可以把 Sass 和 Less 编辑的样式转换为正常的 CSS 样式。他们引入了变量、mixins,参数,嵌套规则,运算,颜色,名字空间,作用域,JavaScript赋值等,加快了 CSS 开发效率。

    二、Sass 和 Less 的区别

    1. 主要区别(实现方式):Less在JS上运行,Sass在Ruby上使用。

    Less基于JavaScript,通过npm安装,在客户端处理 ;Sass基于Ruby,需要安装Ruby,在服务器处理。

    为了使用Less,我们可以将适用的JavaScript文件上传到服务器或通过脱机编译器编译CSS表。

    2. 编写变量的方式不同。

    Sass使用$,而Less使用@。

    3. 在Less中,仅允许循环数值。

    在Sass中,我们可以遍历任何类型的数据;但在Less中,我们只能使用递归函数循环数值。

    4. Sass有Compass,Less有Preboot

    Sass和Less有可用于集成mixins的扩展(在整个站点中存储和共享CSS声明的能力)。

    Sass有适用于mixins的Compass,其中包括所有可用的选项以及未来支持的更新。

    Less有Preboot.less,LESS Mixins,LESS Elements,gs和Frameless。Less的软件支持比Sass更加分散,导致许多不同的扩展选项可能不会以相同的方式运行。对于项目,我们可能需要所有列出的扩展以获得与Compass类似的性能。

    三、Sass 和 Less 的选择

    很多开发者不会选择 Less,因为JavaScript引擎需要额外的时间来处理代码,然后输出修改过的CSS到浏览器。

    四、Less详细

    扩展文件名的格式是 xxx.less

    变量:@

    // Less
    // @变量名:值
    @width:100px;
    
    .box{
        width:@width;
    }

    混合:

    // Less
    // 定义classa,然后可以将classa引入到classb中
    .classa(a){
        width:@width;
    }
    
    .classb{
        .classa(a);
    }

    嵌套规则:

    父级{
        子集
    }

    函数和运算:

    // 可以将值计算
    @the-border: 1px;
    @base-color: #111;
    @red:        #842210;
    
    #header {
      color: @base-color * 3;
      border-left: @the-border;
      border-right: @the-border * 2;
    }
    
    #footer { 
      color: @base-color + #003300;
      border-color: desaturate(@red, 10%);
    }

    五、Sass详细

    扩展文件名的格式是 xxx.scss 或者是 xxx.sass

    变量:$

    // Sass
    // $变量名:值
    $width:100px;
    
    .box{
        width:$width;
    }
    
    如果变量包含字符串则写在 #{}之中
    $c:color;
    
    .box{
        border-#{$c}:red;
    }

    继承:同Less混合相同,定义classa,然后可以将classa引入到classb中。

    //使用方法 定义classa 
    .classb{
        @extend .classa
    }

    嵌套规则:同Less嵌套规则相同。

    Mixin:重用代码块

    //使用方法,先用@mixin命令定义一个代码块
    @mixin left(参数1,参数2){
        float:left;
        margin-left:10px;
    }
    //使用@include调用刚刚定义的代码块
    .box{
        @inclidu left(参数1,参数2);
    }

    插入文件:

    @import命令插入外部文件, .scss和css都可。

    条件语句:

    //@if 可以用来判断, @else 则是配套
    
    .box{
        @if 1+1>1 {width:100px;} @else {
            width:200px;
        }
    }
    

    循环语句:

    // @for @while @each
    
    //@for
    @for $i from 1 to 10{
        border-#{$i}{
            border:#{$i}px solid red;
        }
    }
    
    //@while
    $i:6;
    @while $i>0{
        .item-#{$i}{
            width:2em*$i;
        }
        $i:$i-2;
    }
    
    //@each
    @each $member in a, b, c, d {
      .#{$member} {
        background-image: url("/image/#{$member}.jpg");
      }
    }
    

    自定义函数:

    @function name($n){
        @return $n*2;
    }
    
    .box{
        width:name(value);
    }

    参考:

    https://m.php.cn/article/413479.html

    https://www.jianshu.com/p/e3f1fcbbccc3

    END

    展开全文
  • CSS预处理器 Less & Sass

    2017-04-25 16:50:32
    查阅了许多相关css预处理器LessSass的资料,部分内容引用原作者。自己总结了下。 共性有一下几点: 混合(Mixins):class中的class; 参数混合(Parametric):可以像函数一样传递参数的class; 嵌套规则...

    查阅了许多相关css预处理器Less和Sass的资料,部分内容引用原作者。

    自己总结了下。
    共性有一下几点:

    混合(Mixins):class中的class;
    参数混合(Parametric):可以像函数一样传递参数的class;
    嵌套规则(Nested Rules):class中嵌套class,从而减少重复的代码;
    运算(Operations):css中的数学计算;
    颜色功能(Color function):可以编辑你的颜色;
    命名空间(Namespaces):样式分组,从而方便被调用;
    作用域(Scope):局部修改样式;
    JavaScript表达式(Javascript evaluation):在CSS样式中使用Javascript表达式赋值;

    简单说下我的理解:

    现在可以在用js的各种表达式写样式文件了,有函数,变量,引用引入,标签和属性的嵌套,继承,各类选择器,循环和if判断语句,;熟悉运用后可减少重复代码,大大提高效率。
    将定义过的class A引入class B中,从而实现B继承A的属性;可以导入公共部分的代码,可设置全局变量。
    class中嵌套class的写法,减少重复代码。主要作用是在开发阶段能有效的增强代码的可阅读性、可维护性。
    数学运算可用于属性值和颜色值,利于我们处理稍复杂的运算。
    颜色的函数运算,试我们变换颜色更方便。
    命名空间,可将变量或混合模块封装,重复使用,提高利用率。
    作用域,查找到符合的本地变量,没找到就向上查找。

    主要区别是使用方式不同:

    less是基于javascript的,在客户端处理;
    需要注意的是,less输出修改过的CSS到浏览器需要依赖于Javascript引擎,而Javascript引擎需要额外的时间来处理;
    这种情况可以只在开发阶段使用less,开发完成后,将less输出内容复制到单独的css文件用来代替less文件。
    也可以使用less转义工具编译压缩你的代码,比如 LESS APP;

    下载一个less.js脚本:

    <link rel="stylesheet/less" type="text/css" href="styles.less">
    <script src="less.js" type="text/javascript"></script>

    注意rel后面是stylesheet/less,less.js放在less样式之后引入。

    sass基于ruby,需要在服务端处理。
    依赖于ruby环境。
    编译上可能没有less那么直接,less更适合node。

    具体的语法,在这里简单列几条
    本人的第一篇博客,先尝试着发布一下。。。之后补上

    更多教程了解:
    sass教程:
    http://www.w3cplus.com/sassguide/
    less中文网
    http://lesscss.cn/

    著作权归作者所有。
    商业转载请联系作者获得授权,非商业转载请注明出处。
    原文: http://www.w3cplus.com/css/an-introduction-to-less-and-comparison-to-sass.html © w3cplus.com
    英文原文:http://coding.smashingmagazine.com/2011/09/09/an-introduction-to-less-and-comparison-to-sass/

    中文译文:http://www.w3cplus.com/css/an-introduction-to-less-and-comparison-to-sass.html

    展开全文
  • 1:什么是CSS预处理器? 基于CSS的另一种语言 可通过工具编译成CSS 添加了很多CSS不具备的特性 能提升CSS文件的组织方式 2:CSS 预处理器作用 帮助更好的组织CSS代码 提高代码的复用率 提升可维护性 3:预处理器...
  • 本文将主要介绍 SassLess 和 Stylus 这三种 css 预处理器,将从各个角度比较它们的异同。 我们曾经面对 css 很多令人发指的不友好特性,也因为 css 的低复用性而刀耕火种。 css 预处理器就是这样被创造出来,...
  • 在这篇文章中,我们将介绍三种不同CSS预处器的蛮量、功能以及他们的好处——sassless和stylus。 介绍 CSS预处理器是一种语言,用来编写一些CSS的特性,而且无需考虑浏览器兼容性的问题。他们通过编译的代码编写...
  • css预处理器是一种语言用来为css增加一些编程的特性,无需考虑浏览器的兼容性问题,最为普遍的三款CSS预处理器框架分别是SassLess Css、Stylus。 css-loader 它在作用在于在使用webpack打包的时候,如果碰到...
  • 什么是css预处理器 CSS 预处理器是一种语言。 用通俗易懂的话来说就是“用一种专门的编程语言,进行 Web 页面样式编写,再通过编译器转化为正常的 CSS 文件”,无需考虑浏览器的兼容性问题。 可以在 C...
  • css预处理器 什么是css预处理器:扩展了 CSS 语言,包含(变量,运算,函数),使 CSS 更易维护和扩展。 1》less 中文网:http://lesscss.cn/ a)编译 node: 1》npm install -g less 2》 编译成为压缩版本:...
  • http://www.w3cplus.com/css/css-preprocessor-sass-vs-less-stylus-2.html 一、什么是CSS预处器 CSS预处理器定义了一种新的语言,其基本思想是,用一种专门的编程语言,为CSS增加了一些编程的特性,将CSS作为目标...
  • css预处理器sass

    2017-01-18 15:57:20
    Sass 是一种css预处理器,CSS 预处理器定义了一种新的语言,其基本思想是,用一种专门的编程语言,为 CSS 增加了一些编程的特性,将 CSS 作为目标生成文件,然后开发者就只要使用这种语言进行编码工作。 除了sass...
  • CSS预处理器SASS用法指南 一、什么是SASS Sass是是一种基于ruby编写的CSS预处理器,提供了许多便利的写法,大大节省了设计者的时间,使得CSS的开发,变得简单和可维护。 诞生于2007年,是最早也是最成熟的一...
  • CSS预处理器(SASSLESS)

    2018-09-09 18:51:00
    Sass框架应用Sass简介 Sass又名SCSS,是CSS预处理器之一,它能让你更好更轻松的工作。Sass官网是这样描述Sass的:**Sass是一门高于CSS的元语言,能用来清晰的、结构化地描述文件样式,能提供更简洁优雅的语法,提供...
  • Sass and LESS both are CSS Preprocessors. These are two of the most commonly used processors in the industry. CSS processors are very powerful and help you to streamline the development process. Altho...
  • 一、什么是CSS预处器CSS预处理器定义了一种新的语言,其基本思想是,用一种专门的编程语言,为CSS增加了一些编程的特性,将CSS作为目标生成文件,然后开发者就只要使用这种语言进行编码工作。通俗的说,CSS预处理器...
  • 一、什么是CSS预处理器 CSS预处理器定义了一种新的语言,基本的思想是用一种专门的编程语言,开发者只... CSS预处理器种类繁多,本次就以SassLess、Stylus进行比较。二、语法 在使用CSS预处理器之前最重要的是...
  • Less:预处理 CSS,支持变量、混合、函数、嵌套、循环等特点,Less 可以运行在 Node 或浏览器端 Sass:是一款强化 CSS 的辅助工具,它在css的基础上添加了 变量、混入(mixin)、继承、函数、嵌套、导入 等强大的...
  • CSS预处理器的原理: 是将类 CSS 语言通过Webpack 编译转成浏览器可读的真正 CSS。在这层编译之上,便可以赋予 CSS 更多更强大的功能,常用功能: 嵌套 变量 循环语句 条件语句 自动前缀 单位转换 mixin复用 .....
  • css预处理器sass

    2016-02-29 15:08:51
    本文参考文献:http://www.ruanyifeng.com/blog/2012/06/sass.html ... ... CSS 预处理器是一种语言用来为 CSS 增加一些编程的的特性,无需考虑浏览器的兼容性问题,例如你可以在
  • CSS预处理器sass

    2020-10-10 12:34:15
    介于已经写了less的博客,本次主要是写一下lesssass的区别: 我的less博客传送门: https://blog.csdn.net/weixin_43689603/article/details/108970219 那么开始讲语法之前先需要下载ruby,因为sass需要在ruby环境...
  • 什么是 CSS 预处理?为什么要有 CSS 预处理? 可以实现css变量和函数的功能 ,给我们带来动态语言所具有的优势。 less 1. less文件必须以.less结尾 2. 定义变量:@字符开头 @bgColor:#000;//定义变量 //编译前less ...
  • 在之前我写过一篇CSS进阶:LESS快速入门的文章,这次这个sassless一样是css预处理器,同样对对css的编写提高不少的效率,虽然sassless用法都差不多,但在网上浏览博客时,总是发现sassless讨论的人更多,用的...
  • CSS 预处理器是一种语言用来为 CSS 增加一些编程的的特性,无需考虑浏览器的兼容性问题,例如你可以在 CSS 中使用变量、简单的程序逻辑、函数等等在编程语言中的一些基本技巧,可以让你的 CSS 更见简洁,适应性更强...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,836
精华内容 3,934
关键字:

css预处理器less、sass