精华内容
下载资源
问答
  • 笔记的好处 1.加深记忆,防止遗忘 2.通过笔记,可以理解掌握疑难点,防止以后犯同样的错误 3.记笔记可以培养总结整理的好习惯 4.好记性不如烂笔头 如何记笔记 ...

    记笔记的好处

    1.加深记忆,防止遗忘
    2.通过笔记,可以理解掌握疑难点,防止以后犯同样的错误
    3.记笔记可以培养总结整理的好习惯
    4.好记性不如烂笔头
    5.使笔记能够清楚的表达,可以将事情描述清楚
    6.方便理解,查漏补缺

    如何记笔记

    1、将笔记尽量写的详细,清楚
    2、写完以后多读,多用,体会,思考如何将事情描述清楚
    3、多使用记录截图,一图胜千言
    4、多用自己的话来概括总结问题,方便理解,查漏补缺
    5、记录完的笔记可以补充新的理解或体会
    6、记录笔记要讲究条理分明,列出每一步步骤(1、 2、 3、4)

    展开全文
  • React学习笔记_总结

    千次阅读 2017-11-23 17:13:44
    react学习笔记总结 做React需要会什么? react的功能其实很单一,主要负责渲染的功能,现有的框架,比如angular是一个大而全的框架,用了angular几乎就不需要用其他工具辅助配合,但是react不一样,他只负责ui...

    react学习笔记总结

    做React需要会什么?

    react的功能其实很单一,主要负责渲染的功能,现有的框架,比如angular是一个大而全的框架,用了angular几乎就不需要用其他工具辅助配合,但是react不一样,他只负责ui渲染,想要做好一个项目,往往需要其他库和工具的配合,比如用redux来管理数据,react-router管理路由,react已经全面拥抱es6,所以es6也得掌握,webpack就算是不会配置也要会用,要想提高性能,需要按需加载,immutable.js也得用上,还有单元测试。。。。

    React 是什么

    用脚本进行DOM操作的代价很昂贵。有个贴切的比喻,把DOM和JavaScript各自想象为一个岛屿,它们之间用收费桥梁连接,js每次访问DOM,都要途径这座桥,并交纳“过桥费”,访问DOM的次数越多,费用也就越高。 因此,推荐的做法是尽量减少过桥的次数,努力待在ECMAScript岛上。因为这个原因react的虚拟dom就显得难能可贵了,它创造了虚拟dom并且将它们储存起来,每当状态发生变化的时候就会创造新的虚拟节点和以前的进行对比,让变化的部分进行渲染。整个过程没有对dom进行获取和操作,只有一个渲染的过程,所以react说是一个ui框架。

    React的组件化

    react的一个组件很明显的由dom视图和state数据组成,两个部分泾渭分明。state是数据中心,它的状态决定着视图的状态。这时候发现似乎和我们一直推崇的MVC开发模式有点区别,没了Controller控制器,那用户交互怎么处理,数据变化谁来管理?然而这并不是react所要关心的事情,它只负责ui的渲染。与其他框架监听数据动态改变dom不同,react采用setState来控制视图的更新。setState会自动调用render函数,触发视图的重新渲染,如果仅仅只是state数据的变化而没有调用setState,并不会触发更新。 组件就是拥有独立功能的视图模块,许多小的组件组成一个大的组件,整个页面就是由一个个组件组合而成。它的好处是利于重复利用和维护。

    React的 Diff算法

    react的diff算法用在什么地方呢?当组件更新的时候,react会创建一个新的虚拟dom树并且会和之前储存的dom树进行比较,这个比较多过程就用到了diff算法,所以组件初始化的时候是用不到的。react提出了一种假设,相同的节点具有类似的结构,而不同的节点具有不同的结构。在这种假设之上进行逐层的比较,如果发现对应的节点是不同的,那就直接删除旧的节点以及它所包含的所有子节点然后替换成新的节点。如果是相同的节点,则只进行属性的更改。

    对于列表的diff算法稍有不同,因为列表通常具有相同的结构,在对列表节点进行删除,插入,排序的时候,单个节点的整体操作远比一个个对比一个个替换要好得多,所以在创建列表的时候需要设置key值,这样react才能分清谁是谁。当然不写key值也可以,但这样通常会报出警告,通知我们加上key值以提高react的性能。

    React组件是怎么来的

    组件的创造方法为React.createClass() ——创造一个类,react系统内部设计了一套类系统,利用它来创造react组件。但这并不是必须的,我们还可以用es6的class类来创造组件,这也是Facebook官方推荐的写法。

    这两种写法实现的功能一样但是原理却是不同,es6的class类可以看作是构造函数的一个语法糖,可以把它当成构造函数来看,extends实现了类之间的继承 —— 定义一个类Main 继承React.Component所有的属性和方法,组件的生命周期函数就是从这来的。constructor是构造器,在实例化对象时调用,super调用了父类的constructor创造了父类的实例对象this,然后用子类的构造函数进行修改。这和es5的原型继承是不同的,原型继承是先创造一个实例化对象this,然后再继承父级的原型方法。了解了这些之后我们在看组件的时候就清楚很多。

    当我们使用组件< Main />时,其实是对Main类的实例化——new Main,只不过react对这个过程进行了封装,让它看起来更像是一个标签。

    有三点值得注意:1、定义类名字的首字母必须大写 2、因为class变成了关键字,类选择器需要用className来代替。 3、类和模块内部默认使用严格模式,所以不需要用use strict指定运行模式。

    组件的生命周期

    组件在初始化时会触发5个钩子函数:

    1、getDefaultProps()

    设置默认的props,也可以用dufaultProps设置组件的默认属性。

    2、getInitialState()

    在使用es6的class语法时是没有这个钩子函数的,可以直接在constructor中定义this.state。此时可以访问this.props。

    3、componentWillMount()

    组件初始化时只调用,以后组件更新不调用,整个生命周期只调用一次,此时可以修改state。

    4、 render()

    react最重要的步骤,创建虚拟dom,进行diff算法,更新dom树都在此进行。此时就不能更改state了。

    5、componentDidMount()

    组件渲染之后调用,可以通过this.getDOMNode()获取和操作dom节点,只调用一次。

    在更新时也会触发5个钩子函数:

    6、componentWillReceivePorps(nextProps)

    组件初始化时不调用,组件接受新的props时调用。

    7、shouldComponentUpdate(nextProps, nextState)

    react性能优化非常重要的一环。组件接受新的state或者props时调用,我们可以设置在此对比前后两个props和state是否相同,如果相同则返回false阻止更新,因为相同的属性状态一定会生成相同的dom树,这样就不需要创造新的dom树和旧的dom树进行diff算法对比,节省大量性能,尤其是在dom结构复杂的时候。不过调用this.forceUpdate会跳过此步骤。

    8、componentWillUpdate(nextProps, nextState)

    组件初始化时不调用,只有在组件将要更新时才调用,此时可以修改state

    9、render()

    不多说

    10、componentDidUpdate()

    组件初始化时不调用,组件更新完成后调用,此时可以获取dom节点。

    还有一个卸载钩子函数

    11、componentWillUnmount()

    组件将要卸载时调用,一些事件监听和定时器需要在此时清除。

    以上可以看出来react总共有10个周期函数(render重复一次),这个10个函数可以满足我们所有对组件操作的需求,利用的好可以提高开发效率和组件性能。

    React-Router路由

    Router就是React的一个组件,它并不会被渲染,只是一个创建内部路由规则的配置对象,根据匹配的路由地址展现相应的组件。Route则对路由地址和组件进行绑定,Route具有嵌套功能,表示路由地址的包涵关系,这和组件之间的嵌套并没有直接联系。Route可以向绑定的组件传递7个属性:children,history,location,params,route,routeParams,routes,每个属性都包涵路由的相关的信息。比较常用的有children(以路由的包涵关系为区分的组件),location(包括地址,参数,地址切换方式,key值,hash值)。react-router提供Link标签,这只是对a标签的封装,值得注意的是,点击链接进行的跳转并不是默认的方式,react-router阻止了a标签的默认行为并用pushState进行hash值的转变。切换页面的过程是在点击Link标签或者后退前进按钮时,会先发生url地址的转变,Router监听到地址的改变根据Route的path属性匹配到对应的组件,将state值改成对应的组件并调用setState触发render函数重新渲染dom。

    当页面比较多时,项目就会变得越来越大,尤其对于单页面应用来说,初次渲染的速度就会很慢,这时候就需要按需加载,只有切换到页面的时候才去加载对应的js文件。react配合webpack进行按需加载的方法很简单,Route的component改为getComponent,组件用require.ensure的方式获取,并在webpack中配置chunkFilename。

    const chooseProducts = (location, cb) => {
        require.ensure([], require => {
            cb(null, require('../Component/chooseProducts').default)
        },'chooseProducts')
    }
    
    const helpCenter = (location, cb) => {
        require.ensure([], require => {
            cb(null, require('../Component/helpCenter').default)
        },'helpCenter')
    }
    
    const saleRecord = (location, cb) => {
        require.ensure([], require => {
            cb(null, require('../Component/saleRecord').default)
        },'saleRecord')
    }
    
    const RouteConfig = (
        <Router history={history}>
            <Route path="/" component={Roots}>
                <IndexRoute component={index} />//首页
                <Route path="index" component={index} />
                <Route path="helpCenter" getComponent={helpCenter} />//帮助中心
                <Route path="saleRecord" getComponent={saleRecord} />//销售记录
                <Redirect from='*' to='/'  />
            </Route>
        </Router>
    );
    

    组件之间的通信

    react推崇的是单向数据流,自上而下进行数据的传递,但是由下而上或者不在一条数据流上的组件之间的通信就会变的复杂。解决通信问题的方法很多,如果只是父子级关系,父级可以将一个回调函数当作属性传递给子级,子级可以直接调用函数从而和父级通信。

    组件层级嵌套到比较深,可以使用上下文getChildContext来传递信息,这样在不需要将函数一层层往下传,任何一层的子级都可以通过this.context直接访问。

    兄弟关系的组件之间无法直接通信,它们只能利用同一层的上级作为中转站。而如果兄弟组件都是最高层的组件,为了能够让它们进行通信,必须在它们外层再套一层组件,这个外层的组件起着保存数据,传递信息的作用,这其实就是redux所做的事情。

    组件之间的信息还可以通过全局事件来传递。不同页面可以通过参数传递数据,下个页面可以用location.param来获取。其实react本身很简单,难的在于如何优雅高效的实现组件之间数据的交流。

    Redux

    首先,redux并不是必须的,它的作用相当于在顶层组件之上又加了一个组件,作用是进行逻辑运算、储存数据和实现组件尤其是顶层组件的通信。如果组件之间的交流不多,逻辑不复杂,只是单纯的进行视图的渲染,这时候用回调,context就行,没必要用redux,用了反而影响开发速度。但是如果组件交流特别频繁,逻辑很复杂,那redux的优势就特别明显了。我第一次做react项目的时候并没有用redux,所有的逻辑都是在组件内部实现,当时为了实现一个逻辑比较复杂的购物车,洋洋洒洒居然写了800多行代码,回头一看我自己都不知道写的是啥,画面太感人。

    先简单说一下redux和react是怎么配合的。react-redux提供了connect和Provider两个好基友,它们一个将组件与redux关联起来,一个将store传给组件。组件通过dispatch发出action,store根据action的type属性调用对应的reducer并传入state和这个action,reducer对state进行处理并返回一个新的state放入store,connect监听到store发生变化,调用setState更新组件,此时组件的props也就跟着变化。

    流程是这个样子的:

    值得注意的是connect,Provider,mapStateToProps,mapDispatchToProps是react-redux提供的,redux本身和react没有半毛钱关系,它只是数据处理中心,没有和react产生任何耦合,是react-redux让它们联系在一起。

    接下来具体分析一下,redux以及react-redux到底是怎么实现的。

    先上一张图

    明显比第一张要复杂,其实两张图说的是同一件事。从上而下慢慢分析:

    先说说redux:

    redux主要由三部分组成:store,reducer,action。

    store是一个对象,它有四个主要的方法:

    1、dispatch:

    用于action的分发——在createStore中可以用middleware中间件对dispatch进行改造,比如当action传入dispatch会立即触发reducer,有些时候我们不希望它立即触发,而是等待异步操作完成之后再触发,这时候用redux-thunk对dispatch进行改造,以前只能传入一个对象,改造完成后可以传入一个函数,在这个函数里我们手动dispatch一个action对象,这个过程是可控的,就实现了异步。

    2、subscribe:

    监听state的变化——这个函数在store调用dispatch时会注册一个listener监听state变化,当我们需要知道state是否变化时可以调用,它返回一个函数,调用这个返回的函数可以注销监听。 let unsubscribe = store.subscribe(() => {console.log('state发生了变化')})

    3、getState:

    获取store中的state——当我们用action触发reducer改变了state时,需要再拿到新的state里的数据,毕竟数据才是我们想要的。getState主要在两个地方需要用到,一是在dispatch拿到action后store需要用它来获取state里的数据,并把这个数据传给reducer,这个过程是自动执行的,二是在我们利用subscribe监听到state发生变化后调用它来获取新的state数据,如果做到这一步,说明我们已经成功了。

    4、replaceReducer:

    替换reducer,改变state修改的逻辑。

    store可以通过createStore()方法创建,接受三个参数,经过combineReducers合并的reducer和state的初始状态以及改变dispatch的中间件,后两个参数并不是必须的。store的主要作用是将action和reducer联系起来并改变state。

    action:

    action是一个对象,其中type属性是必须的,同时可以传入一些数据。action可以用actionCreactor进行创造。dispatch就是把action对象发送出去。

    reducer:

    reducer是一个函数,它接受一个state和一个action,根据action的type返回一个新的state。根据业务逻辑可以分为很多个reducer,然后通过combineReducers将它们合并,state树中有很多对象,每个state对象对应一个reducer,state对象的名字可以在合并时定义。

    像这个样子:

    const reducer = combineReducers({
         a: doSomethingWithA,
         b: processB,
         c: c
    })

    combineReducers:

    其实它也是一个reducer,它接受整个state和一个action,然后将整个state拆分发送给对应的reducer进行处理,所有的reducer会收到相同的action,不过它们会根据action的type进行判断,有这个type就进行处理然后返回新的state,没有就返回默认值,然后这些分散的state又会整合在一起返回一个新的state树。

    接下来分析一下整体的流程,首先调用store.dispatch将action作为参数传入,同时用getState获取当前的状态树state并注册subscribe的listener监听state变化,再调用combineReducers并将获取的state和action传入。combineReducers会将传入的state和action传给所有reducer,并根据action的type返回新的state,触发state树的更新,我们调用subscribe监听到state发生变化后用getState获取新的state数据。

    redux的state和react的state两者完全没有关系,除了名字一样。

    上面分析了redux的主要功能,那么react-redux到底做了什么?

    React-Redux

    如果只使用redux,那么流程是这样的:

    component --> dispatch(action) --> reducer --> subscribe --> getState --> component

    用了react-redux之后流程是这样的:

    component --> actionCreator(data) --> reducer --> component

    store的三大功能:dispatch,subscribe,getState都不需要手动来写了。react-redux帮我们做了这些,同时它提供了两个好基友Provider和connect。

    Provider是一个组件,它接受store作为props,然后通过context往下传,这样react中任何组件都可以通过context获取store。也就意味着我们可以在任何一个组件里利用dispatch(action)来触发reducer改变state,并用subscribe监听state的变化,然后用getState获取变化后的值。但是并不推荐这样做,它会让数据流变的混乱,过度的耦合也会影响组件的复用,维护起来也更麻烦。

    connect --connect(mapStateToProps, mapDispatchToProps, mergeProps, options) 是一个函数,它接受四个参数并且再返回一个函数--wrapWithConnect,wrapWithConnect接受一个组件作为参数wrapWithConnect(component),它内部定义一个新组件Connect(容器组件)并将传入的组件(ui组件)作为Connect的子组件然后return出去。

    所以它的完整写法是这样的:connect(mapStateToProps, mapDispatchToProps, mergeProps, options)(component)

    mapStateToProps(state, [ownProps]):

    mapStateToProps 接受两个参数,store的state和自定义的props,并返回一个新的对象,这个对象会作为props的一部分传入ui组件。我们可以根据组件所需要的数据自定义返回一个对象。ownProps的变化也会触发mapStateToProps

    function mapStateToProps(state) {
       return { todos: state.todos };
    }

    mapDispatchToProps(dispatch, [ownProps]):

    mapDispatchToProps如果是对象,那么会和store绑定作为props的一部分传入ui组件。如果是个函数,它接受两个参数,bindActionCreators会将action和dispatch绑定并返回一个对象,这个对象会和ownProps一起作为props的一部分传入ui组件。所以不论mapDispatchToProps是对象还是函数,它最终都会返回一个对象,如果是函数,这个对象的key值是可以自定义的

    function mapDispatchToProps(dispatch) {
       return {
          todoActions: bindActionCreators(todoActionCreators, dispatch),
          counterActions: bindActionCreators(counterActionCreators, dispatch)
       };
    }

    mapDispatchToProps返回的对象其属性其实就是一个个actionCreator,因为已经和dispatch绑定,所以当调用actionCreator时会立即发送action,而不用手动dispatch。ownProps的变化也会触发mapDispatchToProps。

    mergeProps(stateProps, dispatchProps, ownProps):

    将mapStateToProps() 与 mapDispatchToProps()返回的对象和组件自身的props合并成新的props并传入组件。默认返回 Object.assign({}, ownProps, stateProps, dispatchProps) 的结果。

    options:

    pure = true 表示Connect容器组件将在shouldComponentUpdate中对store的state和ownProps进行浅对比,判断是否发生变化,优化性能。为false则不对比。

    其实connect函数并没有做什么,大部分的逻辑都是在它返回的wrapWithConnect函数内实现的,确切的说是在wrapWithConnect内定义的Connect组件里实现的。

    下面是一个完整的 react --> redux --> react 流程:

    一、Provider组件接受redux的store作为props,然后通过context往下传。

    二、connect函数在初始化的时候会将mapDispatchToProps对象绑定到store,如果mapDispatchToProps是函数则在Connect组件获得store后,根据传入的store.dispatch和action通过bindActionCreators进行绑定,再将返回的对象绑定到store,connect函数会返回一个wrapWithConnect函数,同时wrapWithConnect会被调用且传入一个ui组件,wrapWithConnect内部使用class Connect extends Component定义了一个Connect组件,传入的ui组件就是Connect的子组件,然后Connect组件会通过context获得store,并通过store.getState获得完整的state对象,将state传入mapStateToProps返回stateProps对象、mapDispatchToProps对象或mapDispatchToProps函数会返回一个dispatchProps对象,stateProps、dispatchProps以及Connect组件的props三者通过Object.assign(),或者mergeProps合并为props传入ui组件。然后在ComponentDidMount中调用store.subscribe,注册了一个回调函数handleChange监听state的变化。

    三、此时ui组件就可以在props中找到actionCreator,当我们调用actionCreator时会自动调用dispatch,在dispatch中会调用getState获取整个state,同时注册一个listener监听state的变化,store将获得的state和action传给combineReducers,combineReducers会将state依据state的key值分别传给子reducer,并将action传给全部子reducer,reducer会被依次执行进行action.type的判断,如果有则返回一个新的state,如果没有则返回默认。combineReducers再次将子reducer返回的单个state进行合并成一个新的完整的state。此时state发生了变化。dispatch在state返回新的值之后会调用所有注册的listener函数其中包括handleChange函数,handleChange函数内部首先调用getState获取新的state值并对新旧两个state进行浅对比,如果相同直接return,如果不同则调用mapStateToProps获取stateProps并将新旧两个stateProps进行浅对比,如果相同,直接return结束,不进行后续操作。如果不相同则调用this.setState()触发Connect组件的更新,传入ui组件,触发ui组件的更新,此时ui组件获得新的props,react --> redux --> react 的一次流程结束。

    上面的有点复杂,简化版的流程是:

    一、Provider组件接受redux的store作为props,然后通过context往下传。

    二、connect函数收到Provider传出的store,然后接受三个参数mapStateToProps,mapDispatchToProps和组件,并将state和actionCreator以props传入组件,这时组件就可以调用actionCreator函数来触发reducer函数返回新的state,connect监听到state变化调用setState更新组件并将新的state传入组件。

    connect可以写的非常简洁,mapStateToProps,mapDispatchToProps只不过是传入的回调函数,connect函数在必要的时候会调用它们,名字不是固定的,甚至可以不写名字。

    简化版本:

    connect(state => state, action)(Component);

    项目搭建

    上面说了react,react-router和redux的知识点。但是怎么样将它们整合起来,搭建一个完整的项目。

    1、先引用 react.js,redux,react-router 等基本文件,建议用npm安装,直接在文件中引用。

    2、从 react.js,redux,react-router 中引入所需要的对象和方法。

    import React, {Component, PropTypes} from 'react';
    import ReactDOM, {render} from 'react-dom';
    import {Provider, connect} from 'react-redux';
    import {createStore, combineReducers, applyMiddleware} from 'redux';
    import { Router, Route, Redirect, IndexRoute, browserHistory, hashHistory } from 'react-router';

    3、根据需求创建顶层ui组件,每个顶层ui组件对应一个页面。

    4、创建actionCreators和reducers,并用combineReducers将所有的reducer合并成一个大的reduer。利用createStore创建store并引入combineReducers和applyMiddleware。

    5、利用connect将actionCreator,reuder和顶层的ui组件进行关联并返回一个新的组件。

    6、利用connect返回的新的组件配合react-router进行路由的部署,返回一个路由组件Router。

    7、将Router放入最顶层组件Provider,引入store作为Provider的属性。

    8、调用render渲染Provider组件且放入页面的标签中。

    可以看到顶层的ui组件其实被套了四层组件,Provider,Router,Route,Connect,这四个组件并不会在视图上改变react,它们只是功能性的。

    通常我们在顶层的ui组件打印props时可以看到一堆属性:

    上图的顶层ui组件属性总共有18个,如果刚刚接触react,可能对这些属性怎么来的感到困惑,其实这些属性来自五个地方:

    组件自定义属性1个,actionCreator返回的对象6个,reducer返回的state4个,Connect组件属性0个,以及Router注入的属性7个。

    展开全文
  • 如何做好笔记

    千次阅读 2007-10-23 18:35:00
    我觉得做好笔记无论是对于工作还是学习都具有极其重要的作用!在看书或者听课时记笔记,可以让自己理解深刻并便于今后查阅或复习;在开会时作笔记,可以记下会议内容要点以便快速写出会议记录;下面是引自...

    我觉得做好笔记无论是对于工作还是学习都具有极其重要的作用!

    在看书或者听课时记笔记,可以让自己理解深刻并便于今后查阅或复习;

    在开会时作笔记,可以记下会议内容要点以便快速写出会议记录;

    下面是引自http://angelived.org/2007/08/15/geek-to-live-take-great-notes/的一篇如何记笔记的文章,我觉得还不错,与大家共享:
     

    做出优秀的笔记

    <script type="text/javascript"> </script><script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script>

    原文地址:Geek to Live: Take great notes

    译文地址:做出优秀的笔记

    翻译:Savvy,校审 Seapring

    无论喜欢与否,我们的工作时常处于一种会议的状态之中, 会议电话通知,政策研讨会议, 为了会议而会议。但是,只有当每个人走出会议室并将会议内容付诸实践之后,会议才实现了其价值。

    无论你参加完一个商务会议,大学演讲或是一个研讨会议,作出有效的笔记来推动你的项目,工程和你的学业是一项必需的技能。今天我将详细讲解我最喜爱的几种作笔记的方法,因此你可以根据自己的需要自定义你的便签纸。

    前两个方法对于需要把信息分成不同类型的商务会议和专业会议尤其有用。

    方法1:用符号标注下一步动作

    使用便签纸或者在你的膝上型电脑中打开一个文本文件或者在写字板上,用锯齿形的线将笔记的左侧分出一个空白栏。 然后,使用一套简单符号系统在上述栏内标注出4种不同的数据类型。

    • [ ]方括号标注为要做的事
    • ( )圆括号标注为指派给他人的事情
    • * 星号标注为重要的事情
    • ? 问号标注为下一步要研究或是询问的事情

    会议之后, 快速竖向浏览一下页面左边栏处的笔记会使添加任务到工作列表,向别人发送请求,还有促进研究问题都变得容易。(这是Michael Hyatt的想法,他已经清楚地掌握了参加会议的艺术。)

    方法 2: 将你的页面分成四个象限

    视觉上区别信息类型的另一种方法是将你的笔记页分成四个象限并在其中分别记录不同类型的信息-像询问、参考和将要做的事情。传闻说这是比尔盖茨如何记笔记的方法-他以能令人惊异地作详细的会议笔记而闻名。

    方法 3: 记录和概述 - Cornell笔记法

    基于学生们每天要消化更大的信息量,Cornell笔记法也将页面分成不同的区域,如图所示:

    • 笔记区域:尽可能完整而全面地记录演讲。
    • 提示栏:当你做笔记的时候, 让提示栏保持空白。演讲过后,简化你的笔记使之成为简明提示以供日后记忆,回顾和消化(思考)之用。
    • 概要:用一个或二个句子总结你的每页笔记。

    自己动手做便签纸

    在一些小的整洁的网站上提供了很多的格式化了的PDF (一种网络格式)便签纸,在会议之前你可以选择并打印出来装订成册。

    制作便签纸[Simson.net]

    制作一带格的PDF文件,在页眉处放有小日历,并在页面右上角放置可选择的概要框。选择好你的字体并且带有装订孔的为佳。

    Cornell法PDF制作[Study Smarter]

    打印一些按照Cornell法制作的纸张出来,并且不要有具线纹、水平线或者曲线的区域。可选择包括你的名字,日期,班级,并且在装订处留有4个装订孔。还有,水平线要按灰黑相间法去分布。

    记事本制作法[Michael Botsko]

    这种PDF文本样式包括你的名字,班级,日期,项目名称并且将页面分成两个区域: 一是作笔记的部分(带线条),而另一个则是带有时间表的行动栏,并且含有装订孔部分。

    在会议中你使用什么方法做笔记? 你如何保持你的笔记在会议之后仍然思路清晰而且实用? 让我们在lifehacker.com的评论和建议中去了解。

     

    展开全文
  • 测试笔记总结

    千次阅读 2015-08-26 12:48:30
    软件测试笔记  作者:小全子 首先,在此要感谢小全子辛苦整理的笔记,作为刚走入社会的他来说,这样的社会不适合还没完全适应的他,但他是个好孩子,学习刻苦,努力,并没有比同龄人差,甚至我觉得他的选择是...

                        软件测试笔记

                                      作者:小全子

    首先,在此要感谢小全子辛苦整理的笔记,作为刚走入社会的他来说,这样的社会不适合还没完全适应的他,但他是个好孩子,学习刻苦,努力,并没有比同龄人差,甚至我觉得他的选择是对的,比同龄人领先了一步,而这一步他走的很扎实;其次,作为我的好哥们,我很佩服他的努力奋斗精神,我自认没有他那么仔细认真,甚至我有点过于自信。下面是他整理的软测理论笔记,将持续更新。

     

    软件测试概述

    1: 软件测试(test)(广泛的讲):

    测试必须包含的两个过程包含两个结果①预想结果,②实际结果。

    预想结果就是:测试之前先猜想结果会是什么样的;

    实际结果就是:测试之后得到的结果;

    如果前者和后者一致就完成了测试这一过程。

    2:概述(了解即可)

    1)软件测试起源于上世纪70年代中期,在1975年软件测试才被确定为一种研究方向;在1979年Glen Ford Myers的《软件测试的艺术》(The Art of Software Testing)给软件测试定义为:“测试是为了发现错误而执行的一个程序或者系统的过程。”

    2)软件测试在国内的发展历程:

    2000~2005刚开始出现测试,从2005~2008年软件测试逐步兴起,走向了正式的轨道。

    3:概念与目的

    1)软件测试就是:使用人工或自动手段来运行或测试某一系统的过程,其目的在于发现错误,检验是否满足用户需求或弄清预期结果与实际结果的差别。(或,以检验产品是否满足需求为目标)

    2)关于软件测试有不同的定义,有一下几点:

    ①软件测试正向思维

    它的核心思想:测试的方法是试图验证软件是工作的,即软件的功能是按照预先设计的执行的,以正向思维,针对系统的所有功能,逐个验证其正确性。

    软件测试正向思维的出发点:使自己确信产品是能够正常工作的评价一个程序和系统的特性或能力,并确信它是否达到期望的结果,软件测试就是以此为目的的任何行为。

    其实说白了:正向思维思维就是对这个软件抱着没有错的情况下去测试这个软件,然而就测不出任何错误。

    ②软件测试反向思维

    软件测试反向思维就是认为软件有错的情况下去测试这个软件。

    关于软件测试反向思维的三个重要观点:

    a : 测试是为了证明程序有错,而不是证明程序无错的。

    b : 一个好的测试用例在于它能发现以前未发现的错误。

    c : 一个成功的测试是发现了以前未发现错误的测试。

    ③ IEEE定义的测试

    IEEE/ANSI将测试定义为一下两点:

    a : 在规定条件下运行系统或构件的过程。观察和记录结果,并对系统或构件的某些方面给出评价。

    b : 分析软件项目的过程,检测现有状况和所需状况之间的不同,并评估软件项目的特性。

    ④广义软件测试定义

    广义的测试,引入两个概念来覆盖测试的范畴:验证(Verification),确认(Validation)

    验证(Verification):通过检查和提供客观证据来证实指定的需求是否满足。

    确认(Validation):通过检查和提供客观证据来证实特定目的的功能或应用是否已经实现。

    比较V and V的特点:

    验证:就是验证需求是否满足;

    确认:就是确认功能是否实现。

     

    测试的目的:

    以最少的人力,物力和时间找出软件中潜在的各种错误和缺陷,用过修正各种错误和缺陷提高软件质量,避免软件发布后由于潜在的软件错误和缺陷造成的隐患所带来的商业风险。同时利用测试过程中得到的测试结果和测试信息,作为后续项目开发和测试过程改进的重要输入,避免在将来的项目开发和测试中重复同样的错误;采用更高效的测试管理手段,提高软件测试的效率和软件产品的质量。

     

    4:测试和调试的区别

     

     

    测试(test)

    调试(debug)

    目标

    发现缺陷

    差错

    对象

    软件(程序+文档)

    代码

    方法

    多种多样,动静结合

    编译

    周期

    贯穿整个软件生命周期

    只在代码编写阶段

    人员

    测试和开发人员

    开发人员

    开发阶段的软件测试过程:单元测试(unit  testing),集成测试(integration  testing),确认测试(validation  testing),系统测试(system  testing),验收测试(acceptance  testing)。

     

    5:软件的典型错误(课本 7~11)

     

    6:软件测试从业人员的职业要求

    软件测试人员应具备对的素质

    ①    他们善于说服

    ②    他们不放过蛛丝马迹

    ③    他们具有创造性

    ④    他们是问题的发现者

    ⑤    他们是完美追求者

    ⑥    他们是有很好的洞察力

    ⑦    他们是幽默的

    ⑧    他们是善于学习的

     

     

    软件开发生命周期

    1 开发生命周期(life cycle)

    软件:立项,设计,编码测试,发布,淘汰。

     

    获取测试需求

     

    编写测试计划

     

    制定测试方案

     

    开发与设计测试用例

     

    执行测试

     

    提交缺陷报告

     

    测试分析与评审

     

    提交测试总结

     

    准备下一个版本的测试

     

    2 软件开发模型(model)

    1) 瀑布模型

    步骤:需求分析,设计,编程,测试,维护

    特点:严格规定各阶段的任务,上一阶段任务输出作为下一阶段工作输入。

    缺点:测试出现时间太晚,导致没有充足的时间来测试,产品的质量没有了保障。

    修改:从需求分析之后就开始介入测试,其后的步骤都有测试介入,直到整个项目完成。这样既缩短了整个项目的时间,也保障了产品的质量。

    2)快速原型模型

    ①原型是指模拟某种产品的原始模型,在其他产业中经常使用。软件开发中的原型是软件的一个早期可运行的版本,它反映了最终系统的重要特性。

    ②快速原型模型的类型

    a : 探索型原型

    这种类型的原型是把原型用于开发的需求分析阶段,目的是为了弄清用户的需求,确定所期望的特性,并探索各种方案的可行性。它主要针对开发目标模糊,用户与开发都项目缺乏经验的情况,通过对原型的开发来明确用户的需求。

    b : 实验型原型

    这种模型主要用于设计阶段,考核;实现方案是否合适,能否实现。对于一个大型系统,若对设计方案心中没有把握时,可通过阵中原型来证实设计方案的正确性。

    c : 演化型原型

    这种原型主要用于及早向用户提交一个原型系统,该原型系统或者包含系统的框架,或者包含系统的主要功能,在得到用户的认可后,将原型系统不断扩充演变为最终的软件系统。它将原型的思想扩展到软件开发的全过程。

    ③ 快速原型模型的运用方式

    a : 抛弃策略

    将原型用于开发过程的某一阶段,促使该阶段的开发结果更加完整,准确,一致,可靠,该阶段结束后,原型随之作废。探索型和实验型就是采用此策略的。

    b : 附加策略

    将原型用于开发的全过程,原型由最基本的核心开始,逐步增加新的功能和新的需求,反复修改反复扩充,最后发展为用户满意的最终系统,演化型快速原型就是采用此策略。

    ④快速原型模型的开发步骤

    快速分析,构造原型,运行原型,评价原型,修改

     

    3)增量模型和迭代模型

    ①增量模型就是把一软件分成若干个小模块,然后完成每个小模块的功能,再有开发人员将其组装成一个完整的软件

    ②迭代模型

    。步骤:需求分析(可逆)设计(可逆)编程(可逆)测试,维护

     

    4) 螺旋模型

    ①螺旋模型是沿着螺线进行若干次迭代;

    a : 制定计划:确定软件目标,选定实施方案,弄清项目开发的限制条件。

    b : 风险分析:分析评估所选方案,考虑如何识别和消除风险。

    c : 实施工程:实施软件开发和验证。

    d : 客户评估:评价开发工作,提出修改建议,制定下一步计划。

    ②螺旋模型的限制条件:

    a : 螺旋模型强调风险分析,但要求许多客户接受和相信这种分析,并作出相关反应是不容易的,因此,这种模型往往适应内部的大规模软件开发。

    b : 如果执行风险分析将大大影响项目的利润那么进行风险分析毫无意义,因此,螺旋形只适合大规模软件项目。

    c : 软件开发人员应该擅长寻找可能的风险,准确的分析风险,否则将会带来更大的风险。

     

    软件开发过程

     

    1)  软件开发流程:

     

    软件立项

     

     

    可行性研究

     

     

    需求分析

     

     

    概要设计

     

    详细设计

     

    编码实现

     

     

    单元测试

     

     

    集成测试

     

     

    系统测试

    (包含确认测试)

     

    验收测试

     

     

    运行维护

     

     

    注:软件立项到验收测试阶段已经开始测试和测试评审。

    1)  缺陷

    ①    软件缺陷构成示意图:

    15%代码,6%其它,25%需求规格说明书,54%设计

    需求规格说明书:a:分析不到位,不准确b:没有形成相应的文档c:需求没有评审和测试。

    软件需求规格说明在开发,测试,质量保证,项目管理以及相关项目功能中都起了重要作用。对一个复杂产品来说,软件功能需求也许只是系统需求的一个子集,因为另外一些可能属于软件部件。

    ②软件缺陷中的8020原则(即二八原则):

    在软件测试过程中,从需求分析开始到集成测试阶段引入测试手段,能发现所有缺陷的80%;系统测试阶段引入测试手段,能发现剩余缺陷的80%;在运行维护阶段经长时间,大量运行软件后,能够发现剩余的20%。

    例:假如:一个软件有100个缺陷,从需求分析开始到集成测试阶段引入测试手段,能发现所有缺陷的80%,即80个缺陷;系统测试阶段引入测试手段,能发现剩余缺陷的80%;即(1—80%)80%,16个缺陷;在运行维护阶段经长时间,大量运行软件后,能够发现剩余的(1—80%)20%,4个缺陷。

    从价格上体现缺陷发现的阶段与修复之间的成本关系可以得出:(课本24页)

    因此:在软件开发开始阶段,软件测试就要引入,越早引入软件测试,越能早发现缺陷,就可以早修复,这样就可以节省成本,有利于提高软件产品质量。

    2)  软件需求:

    软件需求阶段是整个开发过程中最重要的阶段,也是衡量一个软件产品质量好坏的关键。

    ①    软件需求定义:

    需求分类:

    A : 需求开发:细化需求

    B : 需求管理:对需求审核

    需求开发可进一步分为四个阶段:

    a : 需求获取阶段

    b : 需求分析阶段

    c : 编写需求规格阶段

    d : 需求验证阶段

    需求管理可分为七个阶段:

    a : 定义需求

    b : 需求确认

    c : 建立需求状态

    d : 需求评审

    e : 需求承诺

    f : 需求跟踪

    g :需求变更控制

     

    ②    软件需求过程的标准:

    清楚(clear),完整(complete),一致(consistent),可测试(testable)

    ③    软件需求包括三个不同的层次:

    a : 业务需求(business  requirement)反映了组织机构或客户对系统,产品高层次的目标要求,他们在项目视图与范围文档中予以说明。

    b : 用户需求(user  requirement)文档描述了用户使用产品必须要完成的任务,这在使用实例(user case)文档或方案脚本(scenario)说明中予以说明。

    c : 功能需求(functional  requirement)定义了开发人员必须实现的软件功能,使得用户能完成他们的任务,从而满足业务需求。

     

    其他的看课本。

     

    3)  软件设计

    ①    概要设计:把需求分析得到的文档转换为软件结构和数据结构。

    a : 设计软件结构的具体任务是:将一个复杂系统按功能模块划分,建立模块的层次结构及调用关系,确定模块间的接口及人机界面。

    b : 数据结构设计包括数据特征的描述,确定数据的结构特性,以及数据库的设计,显然总体设计建立的目标系统的逻辑模型与计算机无关。

    ②模块独立性:

    耦合:模块间的连接程度

    内聚:一个模块内部各各元素之间的紧密程度(一个模块值做一件事)

    总之一个良好的软件结构设计:低耦合高内聚,如实在无法平衡,尽可能保持高内聚。

    我的理解:

    例:耦合,就好比一家酒店里在一条走廊里有两排都是单个的房间,高耦合就是每排房间只用一扇门,这样使用起来非常麻烦。低耦合就是每间都有自己的门,这样使用起来就灵活了,不互相打扰。

     

    4)  详要设计

    目标:实现模块功能的算法,要逻辑上正确和算法描述要简明易懂。

    主要任务:设计每个模块的实现算法所需的局部数据结构。

     

     

    总结:

    1)  概要设计实现软件总体设计,模块划分,用户界面设计,数据库设计等等。

    2)  详要设计则根据概要设计所做的模块划分,实现各模块的算法设计实现用户界面设计数据结构设计的细化等。

    需求阶段 (需求规格说明书)   系统测试;

    概要阶段(概要设计文档)   集成测试;

    详要设计  (详细设计文档)   单元测试。

     

    5)  CMM(了解)

    ①    CMM:能力成熟度模型

    ②    SW---CMM:软件能力成熟度模型

    ③    CMM的概貌:

     

    优化及(5)

    (引用其他行业或组织的成熟经验)

    ↑(不断改进的过程)

     

    已管理级(4)

    (高层管理里介入)

    ↑(可预测的过程)

     

    已定义级(3)

    (文档成熟)

    ↑(标准一致的过程)

     

    可重复级(2)

    (文档化(最重要),制度化,标准化)

    ↑(有纪律的过程)

     

    初始级(1)

     

     

    软件测试分类(重点)

    1)  按照开发阶段分

    可分为:单元测试,集成测试,确认测试,系统测试,验收测试。

    a : 单元测试:单元测试又称模块测试,是针对软件的最小单位——程序模块进行正确性检验的正式工作。

    b : 集成测试:也叫组装测试,通常在单元测试的基础上,将所有的程序模块进行有序的递增测试。

    c : 确认测试:是通过检验和提供客观证据,证实软件是否满足特定预期用途的需求,确认测试时检验与证实软件是否满足软件需求说明书中规定的要求。

    d : 系统测试:在真实或模拟系统运行的环境下,检查完整的程序系统能否和系统(包括硬件,外设,网络和系统软件,支持平台)正确配置,连接,并满足用户需求。(除功能外)

    e : 验收测试:按照项目任务书或合同,供需双方约定的验收收据文档进行的对整个系统的测试和评审,决定是否接收或拒收系统。

    { 模拟验收测试:(阿尔法)α测试:有公司内部人员来模拟用户来实施验收测试。β测试:有真实用户参与的验收测试。}

     

    2)  按照测试实施组织划分:

    a : (阿尔法)α测试:有公司内部人员来模拟用户来实施验收测试

    b :β测试:有真实用户参与的验收测试

    c :第三方测试:介于软件开发方和用户之间的测试组织的测试,第三方也称为独立测试。(比如公司甲让公司乙研发一款聊天工具,快研发完成的时候,公司甲怕公司乙自己测会出现质量问题。就委托公司丙调出一个测试团队来到乙公司一同对这款聊天工具进行确认测试)

     

    3)  按照测试技术划分

    白盒测试,黑盒测试,灰盒测试。

    ①    白盒测试:逻辑驱动测试(程序内部的逻辑结构)

    必须要了解程序结构和处理过程,检查是否所有的结构及路径都是正确的,检查软件内部动作是否按照设计说明的规定正常进行。白盒测试又称结构测试。

    ②    黑盒测试:功能驱动测试(软件外在功能的实现,输入和输出的对应关系)黑盒测试不需要考虑内部的逻辑结构,只在界面外进行测试,它只检查样序是否按照需求规格说明书的规定正常实现。

    ③    灰盒测试:介于白盒和黑盒之间的测试。既有逻辑驱动测试也有功能驱动测试。

    例:有一个计算的程序,需求规格说明书上写的当你输入2时,输出的结果为4;其中y=2x;

    当你输入2时,结果为6;则说明这程序有错误,把错误提交上去就OK了,若输出的是4则说明程序正确,这就是黑盒测试。白盒测试就是要知道运算过程,要看代码是不写的y=2x,若是写的代码为y=x^2,若代码是y=x^2就说明程序是错的。灰盒测试测试既要运行当输入2时输出是不是为4,要看其代码是不是y=2x来证明程序的对错。

     

    软件测试方法和技术的分类与软件开发过程相关联,它贯穿了整个软件的生命周期,走查,单元测试,集成测试,系统测试(包含了确认测试),用于整个开发过程的不同阶段开发文档和源程序可以应用单元测试应用走查的方法;单元测试可应用白盒测试方法,集成测试应用近似灰盒的测试方法,而系统测试和确认测试应用黑盒测试方法。

     

    单元测试:→白盒测试(动静结合);

    集成测试:→白为主,黑为辅;

    确认,系统,验收测试:→黑盒测试(动静结合)。

     

    4)  按代码运行划分

    ①    静态测试:指不实际运行被测软件,而只是静态的检查代码,界面或文档中可能存在的错误。

    对于代码测试:主要测试代码是否符合相应的标准和规范。

    对于界面测试:主要测试软件的实际界面与需求中的说明是否相符。

    对于文档测试:主要测试用户手册和需求说明是否真正符合用户的实际需求。

    ②    动态测试:指实际运行被测程序,输入相应的测试数据,检查实际输出的结果和预期结果是否相符的过程,所以我们判断一个测试属于动态测试还是静态测试,唯一的标准就是看是否运行程序,

     

    5)  按软件特性分类

    ①    功能测试:是黑盒测试的一方面,它检查实际软件的功能是否符合用户需求,一般分为逻辑功能测试,界面测试,易用性测试,安装测试,兼容性测试。

    ②    性能测试:(必须的功能测试完成后)软件的性能包含很多方面,主要有时间性能和空间性能两种。

    性能测试一般分为:

    a : 一般性能测试:指让被测系统在正常的软硬件环境下运行,不向其施加任何压力的性能测试。

    b : 稳妥定性测试:也叫可靠性测试,只连续运行被测系统,检查系统运行的稳定程度。

    c :负载测试:通常是指让被测系统在其能忍受的压力的极限范围之内连续运行,来测试系统的稳定性,压力测试:通常是指持续不断地给被测系统增加压力,直到将被测系统压垮为止,用来测试系统能承受的最大压力。

    负载测试:(load testing)能够承受的最大负荷点。

    压力测试:(stress testing)让被测试的物体承受一定压力(要接近最大负荷点),测试其无差错长时间运行的时间段(之内)

    流程:

     

     

    获取测试需求

     

     

    制定测试计划

     

     

    测试计划,开发

     

     

    执行测试

     

     

    测试评审

     

     

    测试总结

     

     

    进入下一个版本测试

     

    过程可以从某一个开始,流程一个都不能拉。

     

    6)  其他分类

    a : 随机测试:(random testing)也有人称为猴子测试,是指测试中所有的输入数据都是随机产生的其目的是模拟用户的真实操作,并发现一些边缘性的错误。

    随机测试还有一种测试叫法就是 ADHOC testing 这种测试方法是根据直觉和经验来判断的。

    b : 冒烟测试(版本验证测试);(必须做,标志测试的开始)只是测试该版本主要功能是否已完成,及是否具有可测性。

    测试步骤:→拿到软件的中间版本→进行冒烟测试→执行测试用例→大范围随意性测试→该版本测试总结。

    c : 回归测试:在当前版本去重复执行之前某一版本所有的测试用例。

    目的:①验证之前某个版本所有缺陷全部被修复

    ②确认修复这些缺陷没有发现新的缺陷。

    若在冒烟测试之后的测试过程中发现了缺陷并给开发人员修复,但是由于开发人员的疏忽又造成了新的缺陷,从而要用到回归测试。它从冒烟测试步骤的执行测试用例→大范围随意性测试之间插入。然后进行测试。

     

    7)  看课本;

     

    8)软件测试的原则

    ①所有测试的标准都是建立在用户需求之上(测试基于需求);

    ③    软件测试必须基于“质量第一”的思想去开展各项工作,当时间和质量冲突时,时间要服从质量(原则);

    ④    事先定义好产品质量的标准,只有有了质量标准,才能根据测试的结果对产品的质量进行分析和评估(CMM);

    ⑤    软件项目已启动,软件测试也就是开始,而不是等程序写完。才开始进行测试(软件测试应该尽早执行);

    ⑥    穷举测试是不可能的(把所有模块都测一遍),甚至一个大小适度的程序,其路径排列的数量也非常大,因此,在测试中不可能运行路径的每一种组合。

    ⑦    第三方进行测试会更客观,更有效;

    ⑧    软件测试计划是做好软件测试的前提(重点);

    ⑨    测试用例是设计出来的,不是写出来的,所以要根据测试的目的,采用相应的方法去设计测试用例,从而提高测试的效率,更多滴发现错误,提高程序的可靠性;

    ⑩    对发现错误较多的程序段,应进行更深入的测试,一般来说,一段程序中已发现的错误越多,其中存在的错误概率就越大;

    ①    重视文档,妥善保存一切测试文档(测试计划,测试用例,测试报告等)

    ②    应当把“尽早和不断地测试”作为测试人员的座右铭;

    ③    回归测试的关联性一定要引起充分的注意,修改一个错误而引起更多错误出现的现象并不少见;

    ④    测试应从“小规模”开始,逐步转向“大规模”;

    ⑤    不可将测试用例置之度外,排除随意性;

    ⑥    必须彻底检查每一个测试结果;

    ⑦    一定要注意测试中的错误集中发现现象,这和程序员的编程水平和习惯有很大的关系;

    ⑧    对测试错误结果一定要有一个确认的过程。

     

                          

                                     测试计划

    计划测试软件工作

    1)  测试计划(test  plan)(文档)

    制定测试目标从以下几方面入手;

    A : 理解系统

    B : 及早介入

    C : 理解企业文化和过程

    D : 测试期望

    E : 吸取教训

    F : 工作量大小

    G : 解决方案的类型

    H: 技术选着(是否引入自动化)

    I : 预算

    J : 时间表

    K : 分阶段的解决方案。

    什么是测试计划?

    规定测试活动的范围,办法,资源和进度;明确正在测试的项目,要测试的特性,要执行的测试任务,每任务的负责人,以及与计划相关的风险。

    2)  测试项目简介:

    ①    产品规格

    产品名称制造商和产品版本号的说明;

    ②    产品信息

    产品的用户,开发该产品的背景

    ③    技术结构

    介绍产品的主要功能,可以借助图表的格式

    3)  测试参考文档

    测试计划中引用的文档或书籍

    4)  测试提交文档

    ①    测试用例

    A : 提供测试用例模板

    B : 确定测试用例的编号规则

    编号最好用这样的:产品名称(包括版本号)___模块名称___测试类型__用例编号

    例:测试腾讯的登陆页面

    Tencent QQ 2012__login__GUI__0001

    (登陆)(页面)

    ②    测试日志

    提供测试日志模块

    ③    缺陷报告

    A : 提供缺陷报告模版(包括包含哪些内容)

    B : 缺陷跟踪系统还是电子文档

    C : 确定严重程度和优先级别怎么划分

    严重程度:当缺陷发生时对于被测对象正常运行的影响程度。

    优先级别:修复缺陷的响应时间。

    ④    测试总结

    提供缺陷总结模板。

     

    软件测试计划的模板(p106)

    测试策略是重点

    展开全文
  • 22号晚zac访谈笔记与seo未来发展总结 2012年10月22日晚,林夕阁对中国seo大佬zac先生进行了一次精彩的访谈,在访谈中zac向我们这些草根站长及seoer指出了seo工作上面需要注意的地方和未来seo的发展方向等问题。于是...
  • 如何做好课堂笔记 俗话说的好,“好记性不如烂笔头”;那么如何最好的做课堂笔记呢?接下来就针对这个问题做一下具体分析。 首先要明白,记笔记记得是什么?哪些内容该记?哪些内容不该记?若是直接把老师课堂讲的,...
  • 怎样才能做好数学笔记  卓越小编教你做好数学笔记的几个秘诀,帮助同学们学习。  一、记提纲 老师讲课大多有提纲,并且讲课时老师会将备课提纲书写在黑板上,这些提纲反映了授课内容的重点、难点,并且有...
  • STM32 CAN通信的学习笔记总结(从小白开始)

    万次阅读 多人点赞 2020-07-30 16:04:15
    本文记录了学习CAN的过程,作为自己以后复习的笔记参考,对于前文的理解或许有些浅显(为了易懂),所涉及到的知识点在后文都会讲到
  • 听老师课堂笔记及感受总结

    千次阅读 热门讨论 2017-07-09 22:30:57
    切勿浪费较多东西去做,用较少的东西,同样可以做好的事情 电影:《接触未来》或者《Contact》 http://pan.baidu.com/share/link?shareid=3817156398&uk=2484421723 4.新概念——思考由来 对于新的...
  • LS路由算法DV路由算法的比较 在王老师的严格要求下,计网学得还是认真的,也读了一些论文,最大遗憾就是期末考试太简单,我的分还不高。o(╥﹏╥)o 文章目录本文排版和主要内容总结于《计算机网络自顶向...
  • 笔记第一阶段总结

    千次阅读 2017-05-29 19:32:53
    吴良航:这几周学习的感想是:程序员的学习之路是非常长的,要做好活到老学到老的准备。这几周的学习,也让我知道了学习一门语言,文档也是很好的学习工具,遇到需要使用的功能,可以去文档上查询相对应的字段。遇到...
  • 软件项目中的复盘,也是通过分析、讨论开发中出现的问题,进而总结成功经验,吸取失败教训,提升团队能力。 复盘为什么没效果 总结不出来有效的结论 没做好是客观原因导致的 知道什么原因,但不知道该怎么办 ...
  • es5、es6、es7知识点的归纳与总结笔记

    千次阅读 多人点赞 2019-12-24 12:51:26
    es5和es6混合 1.super super关键字使得子类调用了父类中的构造函数,父类可以使用子类传进来的属性进行各种运算, super 关键字 还可以调用父类的方法 class Father{ constructor(x,y){ this.x=x;...
  • 笔记总结-相机标定(Camera calibration)原理、步骤

    万次阅读 多人点赞 2018-07-06 19:49:02
    这属于笔记总结。1.为什么要相机标定? 在图像测量过程以及机器视觉应用中,为确定空间物体表面某点的三维几何位置与其在图像中对应点之间的相互关系,必须建立相机成像的几何模型,这些几何模型参数就是相机参数。...
  • 本文来自于简书,文章介绍了用户反馈可以发现自身产品的问题,如何通过需求四要素来做产品的需求挖掘分析,希望对您的学习有所帮助定义需求是满足某类用户的某种欲望或解决某些问题时所产生的现象。工具类App的...
  • 计算机网络笔记总结:Part1 概述

    千次阅读 多人点赞 2020-12-02 14:16:49
    文章参考于B站:王道考研——计算机网络 学习建议: 对于准备找实习且还没学过计网的小伙伴,可以跟着王道考研的教程过一遍知识点...5. 第1章总结 王道考研计算机网络第一部分到此结束,之后还会更新其他及部分的笔记
  • iphone开发笔记和技巧总结

    千次阅读 2013-05-28 16:25:42
     使用NSTimeriphone的简单动画,实现飘雪效果,这理原理比较简单,就是定时生成一定的雪花图片,然后使用动画的方式向下漂落(我在其它论坛,看到使用path的方式实现的一个云漂来漂去的效果,实际也可以用那种...
  • ASP.NET-AJAX笔记总结

    千次阅读 2010-01-27 08:27:00
    1第一个ASP.NET程序 概念:ASP.NET是建立在...优点:浏览器无关方便设置端点、易于调试编译后执行,运行效果提高丰富的控件库创建项目文件同目录下的解决方案(适用于普通系统)步骤:文件——新建——项目——V
  • 类和对象的特性1.对象客观世界中任何一个事物都...2.封装信息隐蔽可以对一个对象进行封装处理,把它的一部分属性和属性对外界屏蔽,也就是说外界是看不到的,甚至不可知的。把对象的内部实现和外部行为分割开来...
  • U-Boot学习笔记总结摘要

    千次阅读 2009-05-05 22:24:00
    一、 BootLoader简介(ZZ):对于计算机系统来说,从...通过这段小程序,我们可以初始化硬件设备、建立内存空间的映射表,从而建立适当的系统软硬件环境,为最终调用操作系统内核做好准备。 对于嵌入式系统,Bootloader
  • 可复制的领导力 重点总结读书笔记

    千次阅读 2018-07-23 16:49:19
    读书笔记 第一章  80%的管理者能达到80分 过去企业管理员工,靠的是严格约束;现在企业管理员工,靠的是相互吸引。一个有野心的管理者,需要将每名员工变成团队的战略合作者。   人人都能学会领导力 在大多数东方...
  • ADB工具使用教程(新手总结笔记

    万次阅读 2020-05-22 13:33:02
    做好两个准备工作:1. 安装好手机的驱动程序 2. 开启手机的usb调试 。 讲两个较为通用使用adb的方法,基本上所有的windows电脑都可以操作 方法一: 点击win,输入cmd,打开命令提示符,或者可以用快捷键“Win+R”...
  • 戴尔笔记本Windows10安装Ubuntu18.04实现双系统总结

    千次阅读 热门讨论 2020-03-24 16:47:47
    如图2: 图2 制作启动盘 图3 制作启动盘 点击写入: 图4 制作启动盘 等一会进度条到100%,启动盘就做好了,这一步一般没问题。   第二步分配一块空间给Ubuntu系统。在键盘上按下win+X键,选择磁盘管理: 图5 磁盘...
  • 实习笔记:实作第一天工作总结

    千次阅读 2017-05-15 18:45:23
    首先谢谢我的老板给我的实习机会,让我得到了提升的机会,非常谢谢,我会做好我的第一份工作,尽心尽力! 第一天实习,第一个来,来了发现没人。9点30人到齐了,一共4个人,我是第五个员工。但是,一个是3年工作...
  • dns mx解析要先做好,gay.com postconf -e “virtual_alias_maps = hash:/etc/postfix/virtual” /etc/postfix/virtual 虚拟名字 真实用户 hello@sb.com westos@westos.com postmap /...
  • IDEA学习笔记

    万次阅读 多人点赞 2021-05-12 18:29:40
    比如插件配置: 1.2.3.2 system目录 system 目录是 IntelliJ IDEA 系统文件目录,是 IntelliJ IDEA 开发项目一个桥梁目录,里面主要有:缓存、索引、容器文件输出等等,虽然不是最重要目录, 但也是最不可或缺的...
  • BN层的11个重要问题总结
  • 改变心态和心情,调节生活的方式和工作的方法,告别因追求完美而拖延逃避,承认自我的不完美,不要太把自己当回事,自身不断成长才是我们应该毕生追求的事情,从这本书挑了6种效应进行重点总结,可以作为了解拖延症...
  • 笔记

    千次阅读 2013-12-31 22:14:43
    ☆ JAVA技能 «  有良好的JAVA基础,熟练掌握面向对象思想: 理解面向对象: ...此相反,线程却共享内存单元(包括代码和数据),通过共享的内存单元来实现数据交换、实时通信必要的同步操作。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,208
精华内容 10,483
关键字:

如何做好笔记与总结