文章目录

1.简介

2.特性

3.演示

3.1 集成

3.2 配置

3.3 创建数据库

3.4 升级数据库

3.5 插入数据

3.6 查询数据

3.7 更新数据

3.8 删除数据

4.版本异同

5.源码地址

1.简介

Litepal——作为带我入行的第一本教学书籍《Android第一行代码》的作者郭霖老师所写出来的持久化框架，几乎算是我接触Android世界之后第一个遇到的框架，故将该框架列为一系列学习框架博客的首位。

根据Litepal的GitHub主页：Litepal，可以看到该框架的一些简介：



LitePal is an open source Android library that allows developers to use SQLite database extremely easy. You can finish most of the database operations without writing even a SQL statement, including create or upgrade tables, crud operations, aggregate functions, etc. The setup of LitePal is quite simple as well, you can integrate it into your project in less than 5 minutes.



事实上，正如这段简介所说，集成Litepal相当简单，不需要超过五分钟时间。使用Litepal，也适合对sql语言还不熟悉的开发者快速上手。



2.特性

让我们继续浏览Litepal的GitHub主页，可以发掘Litepal的一些特性：



Using object-relational mapping (ORM) pattern.

Almost zero-configuration(only one configuration file with few properties).

Maintains all tables automatically(e.g. create, alter or drop tables).

Multi databases supported.

Encapsulated APIs for avoiding writing SQL statements.

Awesome fluent query API.

Alternative choice to use SQL still, but easier and better APIs than the originals.

More for you to explore.

用大白话来描述的话，可以列举如下：



Litepal使用了ORM（对象关系映射）模型

Litepal几乎是无配置的，仅需极少的配置文件

Litepal几乎包括所有的CRUD操作，也支持多张表格的操作

Litepal可以仅调用api进行CRUD操作而避免编写sql语句

总之，看到Litepal具有这么多良好的特性，读者是否心动了呢。理论的话不多说，我们现在就开始正式地使用Litepal进行数据库的相关操作

PS：如果有曾经学习过Java的ORM框架——Mybatis的读者，应该不会对Litepal的使用太陌生，因为它们都使用了xml文件进行相应的配置



3.演示

3.1 集成

现在Android框架的集成相比于IDE还为ADT的时代，要方便了许多。原因是现在的主流IDE是Android Studio，而AS默认使用了Gradle进行版本的配置管理，这让集成框架变得简单了许多。

在build.gradle下，添加以下语句，然后重新sync，即可将Litepal集成到你的项目中：



implementation 'org.litepal.android:java:3.0.0'

1

当然，目前Android的主流开发语言，除了Java之外，还有Kotlin，Litepal同样具有Kotlin版本的（这里的演示仅针对Java，Kotlin版本的异曲同工）依赖：



implementation 'org.litepal.android:kotlin:3.0.0'

1

可以根据个人需求进行配置。



3.2 配置

集成了Litepal之后，要想正式使用它还需要进行一些配置



在assets目录下新建litepal.xml，作为Litepal的全局配置文件，相应的条目信息已作出注释，代码如下：

<?xml version="1.0" encoding="utf-8"?>

<litepal>

    <!--  数据库名  -->

    <dbname value="androidframelearn"/>



    <!--  数据库版本号  -->

    <version value="1"/>



    <!--  指定映射模型  -->

    <list>

       

    </list>



    <!--  指定文件的存储方式  -->

    <!--  <storage value="external" />-->

</litepal>



在你的应用下配置Litepal，有两种方式可以实现：

修改清单文件，将你的应用名修改为：android:name="org.litepal.LitePalApplication"

新建一个自己写的MyOwnApplication类，然后将清单文件中的应用名定位到该类，即：android:name="com.example.MyOwnApplication"，然后再编写MyOwnApplication类，代码如下：

public class MyOwnApplication extends Application {



@Override

public void onCreate() {

    super.onCreate();

    LitePal.initialize(this);

}

...

}



两种方式亦可，Litepal的作者建议若使用第二种方式，需要尽快地调用LitePal.initialize(this);所以将其放在onCreate()方法是最好的。



3.3 创建数据库

刚才在介绍的时候已经说过，Litepal采取的是对象关系映射(ORM)的模式，那么什么是对象关系映射呢？简单点说，我们使用的编程语言是面向对象语言，而使用的数据库则是关系型数据库,那么将面向对象的语言和面向关系的数据库之间建立一种映射关系，这就是对象关系映射了。

不过你可千万不要小看对象关系映射模式，它赋予了我们一个强大的功能，就是可以用面向对象的思维来操作数据库，而不用再和SQL语句打交道了，不信的话我们现在就来体验一下。像往常使用SQLiteOpenHelper类，为了创建一张Book表需要先分析表中应该包含哪些列，然后再编写出一条建表语句，最后在自定义的SQLiteOpenHelper中去执行这条建表语句。但是使用LitePal，你就可以用面向对象的思维来实现同样的功能了，定义一个Book类，代码如下所示：



package com.androidframelearn.dao_litapal;



import org.litepal.crud.LitePalSupport;



public class Book extends LitePalSupport {

    private int id;

    private String author;

    private double price;

    private int pages;

    private String name;

    public int getId(){

        return id;

    }

    public void setId(int id){

        this.id = id;

    }



    public String getAuthor(){

        return author;

    }

    public void setauthor(String author){

        this.author = author;

    }



    public double getPrice(){

        return price;

    }

    public void setPrice(double price){

        this.price = price;

    }



    public int getPages(){

        return pages;

    }

    public void setPages(int pages){

        this.pages = pages;

    }



    public String getName(){

        return name;

    }

    public void setName(String name){

        this.name = name;

    }

}



这里使用标签来声明我们要配置的映射模型类，注意一定要使用完整的类名。不管有多少模型类需要映射，都使用同样的方式配置在标签下即可。

没错，这样就已经把所有工作都完成了，现在只要进行任意一次数据库的操作，BookStore.db数据库应该就会自动创建出来。为了更好地演示代码，我们将布局文件所需要的功能一次性编写好，activity_main.xml代码如下：



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity"

    android:orientation="vertical">



    <Button

        android:id="@+id/btn_db_create"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="创建数据库"/>



    <Button

        android:id="@+id/btn_db_query"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="查询数据"/>



    <Button

        android:id="@+id/btn_db_insert"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="插入数据"/>



    <Button

        android:id="@+id/btn_db_update"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="更新数据"/>



    <Button

        android:id="@+id/btn_db_delete"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:text="删除数据"/>



</LinearLayout>





接下来，修改MainActivity，除了给按钮注册点击事件，还需要编写不同的方法代表不同的逻辑，其中，创建数据库的方法代码如下：



private void createDBbyLitePal() {

        btn_db_create.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Log.i(TAG,"创建数据库成功");

                LitePal.getDatabase();

            }

        });

    }



仅仅通过点击按钮，调用LitePal.getDatabase();这句api，就可以创建出数据库，让我们实际进入项目中尝试一下吧！点击该按钮，然后查看控制台，如图所示：



出现该句日记，说明数据库创建成功，接下来我们看看这个数据库是否按照我们所设置好的格式创建出来了，进入data/data/你的项目包名/databases，即可查看到该数据库已经放置到该目录下，如图所示：





3.4 升级数据库

事实上，若想对现有数据库进行升级，也是可以实现的。以前我们使用SQLiteOpenHelper来升级数据库的方式，虽说功能是实现了，但你有没有发现一个问题,，就是升级数据库的时候我们需要先把之前的表drop掉，然后再重新创建才行。这其实是一个非常严重的问题，因为这样会造成数据丢失，每当升级一次数据库，之前表中的数据就全没了。

而使用Litepal，就可以很好地避免这个问题。假设我们现在有一张新的表Category要加进去，同样编写它的实体类，代码如下：



package com.androidframelearn.dao_litapal;



public class Category {

    private int id;

    private String categoryName;

    private int categoryCode;

    public int getId(){

        return id;

    }

    public void setId(int id){

        this.id = id;

    }



    public String getCategoryName(){

        return categoryName;

    }

    public void setCategoryName(String categoryName){

        this.categoryName = categoryName;

    }



    public int getCategoryCode(){

        return categoryCode;

    }

    public void setCategoryCode(int categoryCode){

        this.categoryCode = categoryCode;

    }

}



改完了所有我们想改的东西，只需要记得在litepal.xml将版本号加1就行了。当然由于这里还添加了一个新的模型类，因此也需要将它添加到映射模型列表中。修改litepal.xml中的代码，如下所示：



<?xml version="1.0" encoding="utf-8"?>

<litepal>

    <!--  数据库名  -->

    <dbname value="androidframelearn"/>



    <!--  数据库版本号  -->

    <version value="2"/>



    <!--  指定映射模型  -->

    <list>

        <mapping class="com.androidframelearn.dao_litapal.Book"/>

        <mapping class="com.androidframelearn.dao_litapal.Category"/>

    </list>



    <!--  指定文件的存储方式  -->

    <!--  <storage value="external" />-->

</litepal>



重新运行一下程序，再次创建数据库，就可以完美地完成数据库的升级了。这里的调试可以使用sqlite工具，这里不再赘述。



3.5 插入数据

在讲述本节时，首先回顾一下之前添加数据的方法，我们需要创建出一个Contentvalues对象，然后将所有要添加的数据put到这个Contentvalues对象当中，最后再调用SQLiteDatabase的insert() 方法将数据添加到数据库表当中，步骤相当繁琐。

而使用LitePal来添加数据，这些操作可以简单到让你惊叹！我们只需要创建出模型类的实例，再将所有要存储的数据设置好，最后调用一下save()方法就可以了。

同样地，修改MainActivity，增加插入数据的事件方法，代码如下：



private void insertDatabyLitePal() {

        btn_db_insert.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Book book = new Book();

                book.setName("The Da Vinci Code");

                book.setauthor("Dan Brown");

                book.setPages(454);

                book.setPrice(16.96);

                book.save();

                Log.i(TAG,"插入数据成功");

            }

        });

    }



同样运行程序，查看控制台，如图所示：



当点击查询数据（下一节将介绍该逻辑）时，控制台打印刚刚插入的数据，如图所示：





3.6 查询数据

使用Litepal同样可以很轻易地查询数据，当然了，由于篇幅限制，这里仅仅贴出最简单的查询方式，至于关联查询等稍复杂的查询方式，可以去GItHub上参考Litepal的官方文档进行相关调用即可。

同样地，修改MainActivity，增加查看数据的事件方法，代码如下：



private void queryDatabyLitePal() {

        btn_db_query.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                List<Book> books = LitePal.findAll(Book.class);

                for (Book book : books){

                    Log.i(TAG,"查询数据成功");

                    Log.d("MainActivity","书名是"+book.getName());

                    Log.d("MainActivity","书的作者是"+book.getAuthor());

                    Log.d("MainActivity","书的页数是"+book.getPages());

                    Log.d("MainActivity","书的价格是"+book.getPrice());

                }

            }

        });

    }



相关的运行结果上一小节以贴出，这里不再重复。



3.7 更新数据

更新数据要比添加数据稍微复杂一点，因为它的API接口比较多，这里我们只介绍最常用的几种更新方式。

首先，最简单的一种更新方式就是对已存储的对象重新设值，然后重新调用save()方法即可。那么这里我们就要了解一个概念，什么是已存储的对象？

对于LitePal来说，对象是否已存储就是根据调用model.isSaved()方法的结果来判断的， 返回true就表示已存储，返回false就表示未存储。那么接下来的问题就是，什么情况下会返回true，什么情况下会返回false呢？

实际上只有在两种情况下model.isSave()方法才会返回true, 一种情况是已经调用过model. save()方法去添加数据了，此时model会被认为是已存储的对象。另一种情况是model对象是通过LitePal提供的查询API查岀来的，由于是从数据库中查到的对象，因此也会被认为是已存储的对象。

由于查询API相对复杂，因此只能先通过第一种情况来进行验证。修改MainActivity中的代码，如下所示：



private void updateDatabyLitePal() {

        btn_db_update.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Book book = new Book();

                book.setName("The Lost Symbol");

                book.setauthor("Dan Brown");

                book.setPages(510);

                book.setPrice(19.95); // 第一次设置商品价格

                book.save();

                book.setPrice(10.99); // 第二次设置商品价格

                book.save();

                Log.i(TAG,"更新数据成功");

            }

        });

    }



可以看到，我们做了跟插入数据类似的事情，但是我们对数据的价格进行了设置，运行程序，如图所示：



可以看到，除了刚刚插入的数据，还有第二条刚刚更新过后的数据。然而这种更新方式只能对已存储的对象进行操作，限制性比较大，接下来我们学习另外一种更加灵巧的更新方式，可以调用以下api：



book.updateAll("name = ? and author = ?","The Lost Symbol","Dan Brown");

1

这里仅贴出其中一条api，其他的可以参考官方文档，这里不再赘述。



3.8 删除数据

使用Litepal删除数据的方式主要有两种，第一种比较简单，就是直接调用已存储对象的delete()方法就可以了，对于已存储对象的概念，我们在之前已经学习过了。也就是说，调用过save()方法的对象，或者是通过LitePal提供的查询API查出来的对象，都是可以直接使用delete()方法来删除数据的。这种方式比较简单，我们就不进行代码演示了，下面直接来看另外一种删除数据的方式。

代码如下：



private void deleteDatabyLitePal() {

        btn_db_delete.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                LitePal.deleteAll(Book.class,"price < ?","15");

                Log.i(TAG,"删除成功");

            }

        });

    }



运行程序，删除过后，按照代码逻辑，已经删除掉了所有price小于15的条目，如图所示：





4.版本异同

之前阅读了郭霖老师所著《Android第一行代码 第二版》时，所记载的Litepal版本为：



compile 'org.litepal.android:core:1.4.1'

1

而的Litepal版本（Java版本，另有Kotlin版本，导入的依赖稍有不同）为：



implementation 'org.litepal.android:java:3.0.0'

1

新旧版本的主要区别是一些类名的划分，例如老板本的DataSupport变成了LitePalSupport，除此之外，一些api的名称也稍有变动，读者在使用时最好可以参考GitHub上的官方文档，及时更新代码，做到与时俱进。



5.源码地址

AFL——Android框架学习

      在TinyUI简介的博客中提到其特点中包含一条，即多数大控件的使用方法和android一直，除了语言差异之外，本篇我们就介绍列表控件TUIListView最简单的使用方法。



        列表组件/控件作为目前Android/iOS的APP中最常用的控件，该控件的设计同时参考Android、windows、Qt等使用的经验进行筛选，最终选择了Android的ListView设计，其他平台的列表中使用难以程度或设计上略逊于Android，因为Android给与了开发者最大的发挥控件，你可以在列表中可以显示任何控件。



        TUIListView中的每一行每一列你可以放置任何UI组件，使用TUIListView需要配合TUIAdapter进行使用，而TinyUI和Android一样提供了内置的简单使用的TUISimpleAdapter。TUISimpleAdapter主要用于显示文本（即每一行都是只能显示文字），如果需要在列表中显示其他UI组件，则需要自定义一个Adapter，关于自定义Adapter将在后续进行详细讲解。



        本篇既然是TUIListView最简单的使用，我们就使用TUISimpleAdapter来显示文本你列表，TUISimpleAdapter最好只用于数据步发生变化的情况，因为其存放的数据使用了C++标准库的vector容器，而非使用list容器，vector容器的特点是访问速度快，但其缺点是vector的内存是连续的，因此内容发生变化可能会造成内存申请和拷贝的动作；而list容器使用的双向链表，其特点是插入数据快，但访问速度慢。



        本篇我们仍然使用上一篇中自定义的MyWindow来显示TUIListView。



使用方法/步骤

1. 定义listView和andapter
   
   
   
           MyWindow中包含TUISimpleAdapter.h的头文件，并定义listView和adapter
   
   
   
   MyWindow.h
   
   
   

   ifndef MY_WINDOW_H
   

   define MY_WINDOW_H
   

   include <TUIWindow.h>
   

   include <TUISimpleAdapter.h>
   

    
   
    
   
    
   
   class MyWindow : public TUIWindow
   
   {
   
   public:
   
       MyWindow(TUIWindow* parent = nullptr);
   
       virtual ~MyWindow();
   
    
   
       void onShow();
   
       void onClose();
   
    
   
   private:
   
       TUIListView listView;
   
       TUISimpleAdapter adapter;
   
   };
   
    
   

   endif // !MY_WINDOW_H
   

    
   
   
   

2. 填充数据，并把adapter设置到listView中
   
   
   
   MyWindow.cpp
   
   
   

   include "MyWindow.h"
   

    
   
    
   
    
   
   MyWindow::MyWindow(TUIWindow* parent)
   
       : TUIWindow(parent)
   
   {
   
       setContentView(&this->listView); // 把listView作为当前窗口的内容视图
   
    
   
    
   
       vector<string> data; // 使用vector<string>类型的data存放数据
   
    
   
       for (int32_t i = 0; i < 20; i++)
   
       {
   
           data.push_back(to_string(i)); // 生成0~20的数值-转换成字符串，放到data中
   
       }
   
    
   
       this->adapter.setData(data); // 把data设置到adapter中
   
    
   
       this->listView.setAdapter(&this->adapter); // 把adapter设置到listView，作为listView数据来源和操作对象
   
   }
   
    
   
   MyWindow::~MyWindow()
   
   {
   
   }
   
    
   
   void MyWindow::onShow()
   
   {
   
   }
   
    
   
   void MyWindow::onClose()
   
   {
   
   }
   
   到目前为止窗口显示列表控件已全部完成，接下来和上一篇一样调用MyWindow的show()方法即可显示，最终结果如下图所示:
   
   
   

目录

1. call 的模拟实现
   
2. apply 的模拟实现
   
3. bind 的模拟实现
   
4. 三者异同
   
   
   
   学习并参考于：
   
   
   
   JavaScript深入之call和apply的模拟实现
   
   
   
   JS的call,apply与bind详解，及其模拟实现
   
   
   
   
   
   （一）call的模拟实现
   
   call 用法 ： MDN Function.prototype.call()
   
   
   
   call() 方法使用一个指定的 this 值和可选的参数列表来调用一个函数。
   
   
   
   call() 提供新的 this 值给当前调用的函数/方法。
   
   
   
5. call 实现主要思路：
   
   将函数设为对象的属性
   
   
   
   执行该函数
   
   
   
   删除该函数
   
   
   
   另外还有考虑：
   
   
   
   call 函数还能给定参数执行函数
   
   this 参数不传，或者传null，undefined， this指向window对象
   
   函数是可以有返回值的
   
6. 实现：
   
   Function.prototype.myCall = function () {
   
     if (typeof this !== 'function') {
   
       throw new TypeError('error!')
   
     }
   
     let context = arguments[0] || window   //this 参数可以传 null，当为 null 的时候，视为指向 window
   
     context.fn = this  // 首先要获取调用call的函数，用this可以获取
   
     let args = [...arguments].slice(1) //从 Arguments 对象中取值，取出第二个到最后一个参数   
   
     let result = context.fn(...args)  //函数是可以有返回值的
   
     delete context.fn
   
     return result
   
   }
   
   
   
7. 测试：
   
   // 测试一下上面实现的myCall
   
   var value = 2;
   
   
   
   var obj = {
   
       value: 1
   
   }
   
   
   
   function bar(name, age) {
   
       console.log(this.value);
   
       return {
   
           value: this.value,
   
           name: name,
   
           age: age
   
       }
   
   }
   
   
   
   bar.call(null); // 2
   
   
   
   console.log(bar.myCall(obj, 'kevin', 18));
   
   // 1
   
   // Object {
   
   //    value: 1,
   
   //    name: 'kevin',
   
   //    age: 18
   
   // }
   
   
   
   （二）apply 的模拟实现
   
   apply 用法：MDN Function.prototype.apply()
   
   
   
   apply() 方法使用一个指定的 this 值和可选的参数数组 来调用一个函数。
   
   
   
   apply 的实现跟 call 类似。
   
   
   
8. 实现：
   
   Function.prototype.myApply = function () {
   
     if (typeof this !== 'function') {
   
       throw new TypeError('error!')
   
     }
   
     let context = arguments[0] || window
   
     context.fn = this
   
     let result = arguments[1] ? context.fn(...arguments[1]) : context.fn()
   
     delete context.fn
   
     return result
   
   }
   
   
   
9. 测试：
   
   var foo = {
   
       value: 1
   
   }
   
   function bar(name, age) {
   
       console.log(name)
   
       console.log(age)
   
       console.log(this.value);
   
   }
   
   bar.myApply(foo, ['black', '18']) // black 18 1
   
   
   
   （三）bind 的模拟实现
   
   bind 用法：MDN Function.prototype.bind()
   
   
   
   bind()方法会创建一个新函数，称为绑定函数。当这个新函数被调用时，bind() 的第一个参数将作为它运行时的 this，之后的一序列参数将会在传递的实参前传入作为它的参数。
   
   
   
   bind是ES5新增的一个方法，不会执行对应的函数，而是返回对绑定函数的引用。
   
   
   
10. 实现：
    
    Function.prototype.customBind = function () {
    
      if (typeof this !== 'function') {
    
        throw new TypeError('error!')
    
      }
    
      const that = this   // 首先要获取调用bind的函数，用this获取并存放在that中
    
      let context = arguments[0] || window
    
      const args = [...arguments].slice(1)
    
      return function() {
    
        return that.apply(context, args.concat([...arguments]))
    
      }
    
    }
    
    
    
    （四）三者异同
    
11. 相同：
    
    改变函数体内 this 的指向
    
12. 不同：
    
    call、apply的区别：call方法接受的是参数列表，而apply方法接受的是一个参数数组。
    
    bind不立即执行。而call或apply会自动执行对应的函数。
    
    
    

目录

JavaScript

1. JS 发展历史
   
2. JS 的特点
   
3. JS 的组成
   
4. JS 的基础语法
   
   a. 两种引入方式 type src
   
   b. 三种输出方式 console.log document.write alert
   
   c. 变量声明 var let const typeof undefined
   
   d. 数据类型简介 string number boolean object undefined
   
   e. 运算符 + - * / % = < > && || !
   
   i. 全等符与不全等符 === !==
   
   f. 流程控制语句
   
   i. 条件语句 if else switch case default break
   
   ii. 循环语句 while dowhile fori forin forof
   

   
   

   
   

   JavaScript

   • JS 用于完成页面与用户的交互功能；

   1. JS 发展历史
   JavaScript 在 1995 年由 Netscape 公司的 Brendan Eich，在网景导航者浏览器上首次设计实现而成。因为 Netscape 与 Sun 合作，Netscape 管理层希望它外观看起来像 Java，因此取名为 JavaScript。但实际上它的语法风格与 Self 及 Scheme 较为接近；
   欧洲计算机制造联盟（ECMA）在 1997 制定脚本语言规范 ECMA Script1 (ES1)，2009 年发布了 ECMA Script5（ES5），在 2015 年发布了 ECMA Script 2015（ES6），所有的浏览器的都支持 ES6；
   

5. JS 的特点
   
   JS 设计模仿了 Java 语言，不同如下：
   
   JS 不需要编译，由浏览器直接解释执行；
   
   JS 是弱类型语言，JS 变量声明不需要指明类型，不同类型的数据可以赋值给同一变量；
   
6. JS 的组成
   
   ECMA Script 是 JS 的基础语法；
   
   BOM（Brower Object Model）是浏览器对象模型；
   
   DOM（Document Object Model）是文档对象模型；
   
7. JS 的基础语法
   
   a. 两种引入方式 type src
   
   
   
   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>JS两种引入方式</title>
   </head>
   <body>
   <!-- JS两种引入方式：JS和CSS一样都需要引入到html页面中，浏览器才会解释执行，JS有两种引入方式：
       1.内嵌(内部)脚本:在script标签中写js代码,script标签推荐放置在body标签的底部,理论上和style标签一样可以放置位置任意；
       2.外部脚步:使用script标签的src属性引入外部js文件,使用注意事项: script标签使用了src属性以后内部的代码不再被浏览器解释执行，script引入外部脚本时不能使用自闭合格式 -->
   <!--告诉浏览器把解析器切换为js解析器 type="text/javascript"可以省略-->
   <script type="text/javascript"> document.write("<h1>内部脚本</h1>");//向body中追加html内容 </script>
   <script src="../js/外部脚本.js"></script>
   </body>
   </html>
   

   
   
   
   
   
   

   b. 三种输出方式 console.log document.write alert

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>JS三种输出方式</title>
   </head>
   <body>
   <!-- JS三种输出方式：
       1.输出到浏览器控制台；
       2.输出html内容到页面；
       3.浏览器弹框输出字符 -->
   <script>
   //1.输出到浏览器控制台
   console.log("1. 输出到浏览器控制台");//开发者专用
   //2.输出html内容到页面
   document.write("2. 输出html内容到页面");//向body中追加html内容
   //3.浏览器弹框输出字符
   alert("3. 浏览器弹框输出字符");//阻塞执行
   </script>
   </body>
   </html>
   

   
   

   
   

   c. 变量声明 var let const typeof undefined

   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>JS变量</title>
   </head>
   <body>
   <!-- JS变量用来存放数据；
       es5以前变量声明使用var；
       es6之后变量声明使用let，常量声明使用const。他们用于替代es6的var声明方式；
    JS是弱类型语言: 
       声明变量时不知道变量的类型(undefined),只有在赋值之后js变量才确定类型；
       typeof(a) 或 typeof a 输出变量的类型；
       undefined表示变量未赋值,未知类型 -->
   <script>
   //字符串 Java声明 String str ="张三";
   let str ="张三";
   console.log(str);
   //整数 Java声明 int k = 5;
   let k = 5;
   console.log(k);
   //小数 Java声明 float f = 7.5;
   let f = 7.5;
   console.log(f);
   //常量 Java声明 final Integer PI = 3.14;
   const PI = 3.14;
   console.log(PI);
   //演示弱类型语言
   let a;//声明变量不需要指明类型
   console.log(typeof a);//undefined 未赋值类型,未知类型
   a = "你好";
   console.log(typeof a);//string
   a = 123;
   console.log(typeof a);//number
   a = true;
   console.log(typeof a);//boolean
   a = new Object();
   console.log(typeof a);//object
   </script>
   </body>
   </html>
   

   
   

   
   

   d. 数据类型简介 string number boolean object undefined

   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>JS数据类型</title>
   </head>
   <body>
   <!-- JS数据类型,常用数据类型:
       1.string 字符串类型;
       2.number 数字.包括整数和小数类型;
       3.boolean 布尔类型.值只有true和false两个;
       4 object 对象类型,空对象使用null表示,有两种格式:
           new Object(); 
           JSON格式.例如:{name:"张三",age:18};
       5.undefined 变量未赋值 -->
   <script>
   //1. string 字符串
   let str = "你好";
   console.log(str);
   console.log(typeof str);//string
   // 2. number 数字
   let n = 123.456;
   console.log(n);
   console.log(typeof n);//number
   // 3. boolean 布尔类型
   let boo = false;
   console.log(boo);
   console.log(typeof boo);//boolean
   // 4. object 对象类型，空对象使用 null表示
   let obj = null;//或 new Object();
   console.log(obj);
   console.log(typeof obj);//object
   // 5. undefined 变量未赋值
   let u = undefined;
   console.log(u);//值是undefined
   console.log(typeof u);//类型是undefined
   // Object类型
   let stu = new Object();//创建一个js对象,js对象的属性想要直接加上
   stu.id = 1;
   stu.name = "刘一";
   stu.age = 18;
   console.log(stu);//{id: 1, name: "刘一", age: 18}
   console.log(typeof stu);//object
   // JS对象取属性值有两种方式:
   // 1. obj.key
   console.log(stu.name);//刘一
   // 2. obj["key"]
   console.log(stu["name"]); //刘一 == stu.name
   let b = "age";
   console.log(stu[b]);//可以取不定属性的值
   </script>
   </body>
   </html>
   

   
   

   
   

   e. 运算符 + - * / % = < > && || !

   
   

   i. 全等符与不全等符 === !==

   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
      <title>JS运算符</title>
   </head>
   <body>
   <!--
   JS运算符
   js运算符和Java运算符基本相同
   只有一个特殊的比较运算符
   === 判断js变量的值和类型都相等才为true
   !== 不全等，判断js变量的值和类型有一个不等就为true
   -->
   <script> let a = 3;
   let b = "3";
   console.log(a == b);//true
   // 全等 运算符 ===
   console.log(a === b);//false
   // 不全等 运算符 !==
   console.log(a !== b);//true
   // 三元(三目)运算符 布尔表达式?真:假
   let str = a===b?"全等":"不全等";
   console.log(str);//不全等
   </script>
   </body>
   </html>
   

   
   

   
   

   f. 流程控制语句

   i. 条件语句 if else switch case default break

   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>条件语句</title>
   </head>
   <body>
   <!-- 条件语句JS的条件语句和Java语法基本一样,但是对数据类型的真假判断有些区别 JS中对各种数据类型作为布尔值的特点:(重点掌握) 1. string 空字符串""为false,其余都为true 2. number 数字 只有0为false,其余数字都为true 3. boolean 布尔类型 值只有 true和false 两个
   循环语句

8. object 对象类型 空对象null表示false,其它对象都是true 5. undefined 变量未赋值 为false 常用语法格式 if ... else if ... else switch case break default -->
   <script>
   //if ... else
   //if(true){
   //if(""){// string 只有空字符为假
   //if(0){number 只有0为假
   //if(false){//boolean false为假 true为真
   //if(null){//object null为假
   //if(undefined){//undefined永为假
   if("undefined"){//undefined永为假
   console.log("满足条件");
   }else{
   console.log("不满足条件");
   }

   //switch case break default
   let k =1;
   switch (k) {
   case 1:
   console.log("111");break;
   case 2:
   console.log("222");break;
   default: console.log("其它情况"); }
   </script>
   </body>
   </html>
   

   
   

   ii. 循环语句 while dowhile fori forin forof

   
   

   <!DOCTYPE html>
   <html lang="zh">
   <head>
   <meta charset="UTF-8">
   <title>循环语句</title>
   </head>
   <body>
   <!-- 循环语句
       while，do while，fori 和Java一样；
       forin
           1.遍历出数组中的索引和元素
           2.遍历出对象中的属性和元素
       forof 
           1.遍历出数组中的元素
       forin 与 forof 区别:
           1.forin可以遍历对象,forof不能遍历对象
           2.forin可以遍历出数组中的索引,forof只能遍历出数组中的元素 -->
   <script>
   //while 和Java一样
   let k=1;
   while (k<3){
       console.log(k++);
   }
   
   //do while 和Java一样
   k =1;
   do{
       console.log(k++);
   }while (k<3)
   
   //fori 和Java一样
   for(let i=0;i<3;i++){
       console.log(i);
   }
   
   //forin 可以遍历数组和对象
   let arr = ["刘一","陈二","张三"];//JS数组使用中括号[]定义
   let stu = {id:5,name:"李四",age:18};//JS对象使用大括号定义
       //1.forin 遍历出数组中的索引
   for(let index in arr){
       console.log(index);//数组的索引 0,1,2
       console.log(arr[index]);//数组中的元素
   }
       //2.forin 遍历出对象中的属性名key
   for(let k in stu){
       console.log(k);//字符串属性 id,name,age
       console.log(stu[k]);//对象中的属性值
   }
   
   //forof 可以遍历数组
   for(let e of arr){
       console.log(e);//数组中的元素
   }</script>
   </body>
   </html>
   

   ————————————————
   版权声明：本文为CSDN博主「Regino」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
   原文链接：https://blog.csdn.net/Regino/article/details/105321573
   

原文链接：https://blog.csdn.net/Regino/article/details/105321573 

发现httppost请求目标网站会出现405 状态码，原因为 Apache、IIS、Nginx等绝大多数web服务器，都不允许静态文件响应POST请求

所以将post请求改为get请求即可

跨域，请求按要求配置完毕之后，options预请求老是报错。原因是webapi 默认的web.config有配置

有这么个配置，导致不行。要把他删掉，还要加上

<!DOCTYPE html>

<html>

<head>

<title>JavaScript实现可视化展示冒泡排序过程</title>

<style>

#boxes{

border:1px solid grey;

width:1320px;

height:300px;

margin-top:10px;

position:relative;

}

.box{

background:red;

width:20px;

line-height:30px;

text-align:center;

font-family:Microsoft Yahei;

font-size:15px;

color:white;

margin:0 1px;

position:absolute;

}

</style>

</head>

<body>

<div id="boxes"></div>

<script>

function random(){

var numbers = [];

for (var i = 0; i < 60; i++) {

var number = Math.floor(Math.random() 90 + 10);

numbers.push(number);

var divElement = document.createElement("div");

var parentElement = document.getElementById("boxes");

divElement.style.left = i 20 + i 2 + "px";

divElement.style.top = 300 - 3 number + "px";

divElement.style.height = 3 number + "px";

divElement.setAttribute("class","box");

parentElement.appendChild(divElement);

}

return numbers;

}

function sort(){

var numbers = random();

var parentElement = document.getElementById("boxes");

var i = 0, j = 0;

var time = setInterval(function() {

if (i < numbers.length) {

if (j < numbers.length - i) {

if (numbers[j] > numbers[j + 1]) {

var temp = numbers[j];

numbers[j] = numbers[j + 1];

numbers[j + 1] = temp;

parentElement.innerHTML = "";

for (var k = 0; k < numbers.length; k++) {

var textNode = document.createTextNode(numbers[k]);

var divElement = document.createElement("div");

divElement.appendChild(textNode);

divElement.style.left = k 20 + k 2 + "px";

divElement.style.top = 300 - 3 numbers[k] + "px";

divElement.style.height = 3 * numbers[k] + "px";

divElement.setAttribute("class","box");

parentElement.appendChild(divElement);

}

}

j++;

}

else{

i++;

j = 0;

}

}

else {

clearInterval(time); 

return;

}

}, 100);  

}

sort();

</script>

</body>

</html>

————————————————

版权声明：本文为CSDN博主「筱葭」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/zhouziyu2011/java/article/details/53899692

HTTP状态码

HTTP状态码（英语：HTTP Status Code）是用以表示网页服务器超文本传输协议响应状态的3位数字代码。它由 RFC 2616 规范定义的，并得到 RFC 2518、RFC 2817、RFC 2295、RFC 2774 与 RFC 4918 等规范扩展。所有状态码的第一个数字代表了响应的五种状态之一。所示的消息短语是典型的，但是可以提供任何可读取的替代方案。 除非另有说明，状态码是HTTP / 1.1标准（RFC 7231）的一部分。



HTTP状态码的官方注册表由互联网号码分配局（Internet Assigned Numbers Authority）维护。



微软互联网信息服务 （Microsoft Internet Information Services）有时会使用额外的十进制子代码来获取更多具体信息，但是这些子代码仅出现在响应有效内容和文档中，而不是代替实际的HTTP状态代码。



HTTP状态码分类



分类 分类描述

1 信息，服务器收到请求，需要请求者继续执行操作

2 成功，操作被成功接收并处理

3 重定向，需要进一步的操作以完成请求

4 客户端错误，请求包含语法错误或无法完成请求

5** 服务器错误，服务器在处理请求的过程中发生了错误

1xx 信息（消息）

这一类型的状态码，代表请求已被接受，需要继续处理。这类响应是临时响应，只包含状态行和某些可选的响应头信息，并以空行结束。由于 HTTP/1.0 协议中没有定义任何 1xx 状态码，所以除非在某些试验条件下，服务器禁止向此类客户端发送 1xx 响应。



100 Continue

继续。客户端应当继续发送请求。

101 Switching Protocols

切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议，例如，切换到HTTP的新版本协议。



2xx 成功

这一类型的状态码，代表请求已成功被服务器接收、理解、并接受。



200 OK

请求成功。请求所希望的响应头或数据体将随此响应返回。出现此状态码是表示正常状态。

201 Created

已创建。成功请求并创建了新的资源。

202 Accepted

已接受。已经接受请求，但未处理完成。

203 Non-Authoritative Information

非授权信息。请求成功，但返回的meta信息不在原始的服务器，而是一个副本。

204 No Content

无内容。服务器成功处理，但未返回内容。在未更新网页的情况下，可确保浏览器继续显示当前文档。

205 Reset Content

重置内容。服务器处理成功，用户终端（例如：浏览器）应重置文档视图。可通过此返回码清除浏览器的表单域。

206 Partial Content

部分内容。服务器成功处理了部分GET请求，类似于 FlashGet 或者迅雷这类的 HTTP下载工具都是使用此类响应实现断点续传或者将一个大文档分解为多个下载段同时下载。



3xx 重定向

这类状态码代表需要客户端采取进一步的操作才能完成请求。通常，这些状态码用来重定向，后续的请求地址（重定向目标）在本次响应的 Location 域中指明。

当且仅当后续的请求所使用的方法是 GET 或者 HEAD 时，用户浏览器才可以在没有用户介入的情况下自动提交所需要的后续请求。客户端应当自动监测无限循环重定向（例如：A->A，或者A->B->C->A），因为这会导致服务器和客户端大量不必要的资源消耗。按照 HTTP/1.0 版规范的建议，浏览器不应自动访问超过5次的重定向。



300 Multiple Choices

多种选择。请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择。

301 Moved Permanently

永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替。

302 Move Temporarily（Found）

临时移动。与301类似，但资源只是临时被移动，客户端应继续使用原有URI。

303 See Other

查看其它地址。与301类似，使用GET和POST请求查看。

304 Not Modified

未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源。

305 Use Proxy

使用代理。所请求的资源必须通过代理访问。

306 Switch Proxy

在版的规范中，306状态码已经不再被使用。它算是已经被废弃的HTTP状态码。

307 Temporary Redirect

临时重定向。与302类似，使用GET请求重定向。



4xx 客户端错误（请求错误）

这类的状态码代表了客户端看起来可能发生了错误，妨碍了服务器的处理。除非响应的是一个 HEAD 请求，否则服务器就应该返回一个解释当前错误状况的实体，以及这是临时的还是永久性的状况。这些状态码适用于任何请求方法。浏览器应当向用户显示任何包含在此类错误响应中的实体内容。

如果错误发生时客户端正在传送数据，那么使用TCP的服务器实现应当仔细确保在关闭客户端与服务器之间的连接之前，客户端已经收到了包含错误信息的数据包。如果客户端在收到错误信息后继续向服务器发送数据，服务器的TCP栈将向客户端发送一个重置数据包，以清除该客户端所有还未识别的输入缓冲，以免这些数据被服务器上的应用程序读取并干扰后者。



400 Bad Request

客户端请求的语法错误，服务器无法理解。

401 Unauthorized

当前请求需要用户验证。

402 Payment Required

该状态码是为了将来可能的需求而预留的。（保留，将来使用。）

403 Forbidden

服务器理解请求客户端的请求，但是拒绝执行此请求。

404 Not Found

请求失败，请求所希望得到的资源未被在服务器上发现。没有信息能够告诉用户这个状况到底是暂时的还是永久的。假如服务器知道情况的话，应当使用410状态码来告知旧资源因为某些内部的配置机制问题，已经永久的不可用，而且没有任何可以跳转的地址。404这个状态码被广泛应用于当服务器不想揭示到底为何请求被拒绝或者没有其他适合的响应可用的情况下。出现这个错误的最有可能的原因是服务器端没有这个页面。

405 Method Not Allowed

客户端请求中的方法被禁止，也就是请求行中指定的请求方法不能被用于请求相应的资源。该响应必须返回一个Allow 头信息用以表示出当前资源能够接受的请求方法的列表。

406 Not Acceptable

服务器无法根据客户端请求的内容特性完成请求，也就是请求的资源的内容特性无法满足请求头中的条件，因而无法生成响应实体。

407 Proxy Authentication Required

与401响应类似，只不过客户端必须在代理服务器上进行身份验证。代理服务器必须返回一个 Proxy-Authenticate 用以进行身份询问。客户端可以返回一个 Proxy-Authorization 信息头用以验证。参见RFC 2617。

408 Request Timeout

请求超时。客户端没有在服务器预备等待的时间内完成一个请求的发送。客户端可以随时再次提交这一请求而无需进行任何更改。

409 Conflict

由于和被请求的资源的当前状态之间存在冲突，请求无法完成。这个代码只允许用在这样的情况下才能被使用：用户被认为能够解决冲突，并且会重新提交新的请求。该响应应当包含足够的信息以便用户发现冲突的源头。

冲突通常发生于对 PUT 请求的处理中。例如，在采用版本检查的环境下，某次 PUT 提交的对特定资源的修改请求所附带的版本信息与之前的某个（第三方）请求向冲突，那么此时服务器就应该返回一个409错误，告知用户请求无法完成。此时，响应实体中很可能会包含两个冲突版本之间的差异比较，以便用户重新提交归并以后的新版本。

410 Gone

客户端请求的资源已经不存在。410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置。

411 Length Required

服务器拒绝在没有定义 Content-Length 头的情况下接受请求。在添加了表明请求消息体长度的有效 Content-Length 头之后，客户端可以再次提交该请求。

412 Precondition Failed

客户端请求信息的先决条件错误，也就是服务器在验证在请求的头字段中给出先决条件时，没能满足其中的一个或多个。这个状态码允许客户端在获取资源时在请求的元信息（请求头字段数据）中设置先决条件，以此避免该请求方法被应用到其希望的内容以外的资源上。

413 Request Entity Too Large

服务器拒绝处理当前请求，因为该请求提交的实体数据大小超过了服务器愿意或者能够处理的范围。此种情况下，服务器可以关闭连接以免客户端继续发送此请求。

如果这个状况是临时的，服务器应当返回一个 Retry-After 的响应头，以告知客户端可以在多少时间以后重新尝试。

414 Request-URI Too Long

请求的URI过长（URI通常为网址），服务器无法处理。

415 Unsupported Media Type

服务器无法处理请求附带的媒体格式，也就是对于当前请求的方法和所请求的资源，请求中提交的实体并不是服务器中所支持的格式，因此请求被拒绝。

416 Requested Range Not Satisfiable

客户端请求的范围无效，也就是如果请求中包含了 Range 请求头，并且 Range 中指定的任何数据范围都与当前资源的可用范围不重合，同时请求中又没有定义 If-Range 请求头，那么服务器就应当返回416状态码。

417 Expectation Failed

服务器无法满足Expect的请求头信息，也就是在请求头 Expect 中指定的预期内容无法被服务器满足，或者这个服务器是一个代理服务器，它有明显的证据证明在当前路由的下一个节点上，Expect 的内容无法被满足。



5xx 服务器错误

这类状态码代表了服务器在处理请求的过程中有错误或者异常状态发生，也有可能是服务器意识到以当前的软硬件资源无法完成对请求的处理。除非这是一个HEAD 请求，否则服务器应当包含一个解释当前错误状态以及这个状况是临时的还是永久的解释信息实体。浏览器应当向用户展示任何在当前响应中被包含的实体。这些状态码适用于任何响应方法。



500 Internal Server Error

服务器内部错误，无法完成请求。服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在服务器端的源代码出现错误时出现。

501 Not Implemented

服务器不支持当前请求所需要的某个功能。当服务器无法识别请求的方法，并且无法支持其对任何资源的请求。

502 Bad Gateway

作为网关或者代理工作的服务器尝试执行请求时，从远程服务器接收到了一个无效的响应。

503 Service Unavailable

由于临时的服务器维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复。如果能够预计延迟时间，那么响应中可以包含一个 Retry-After 头用以标明这个延迟时间。如果没有给出这个 Retry-After 信息，那么客户端应当以处理500响应的方式处理它。

注意：503状态码的存在并不意味着服务器在过载的时候必须使用它。某些服务器只不过是希望拒绝客户端的连接。

504 Gateway Timeout

作为网关或者代理工作的服务器尝试执行请求时，未能及时从上游服务器（URI标识出的服务器，例如HTTP、FTP、LDAP）或者辅助服务器（例如DNS）收到响应。

505 HTTP Version Not Supported

服务器不支持，或者拒绝支持在请求中使用的 HTTP 版本。这暗示着服务器不能或不愿使用与客户端相同的版本。响应中应当包含一个描述了为何版本不被支持以及服务器支持哪些协议的实体。



感谢观看！

参考资料：

https://www.runoob.com/http/http-status-codes.html

若想了解更多请参考：

HTTP状态码百度百科

https://blog.csdn.net/GarfieldEr007/article/details/77984065

HTML基础知识

第一篇，HTML的结构

HTML中两个概念

(1).HTML标签：<元素名称></元素名称>

  完整语法：<元素名称>要控制的元素</元素名称>

HTML标签分为两种： 成对：只对标签内的元素起作用

                                    单独：在相应位置插入换行

标签属性设置在元素的首标签：语法：<元素 属性1=“值1” …>元素资料</元素>,""可省略

HTML元素： 一组标签将一段文字包含在中间，这一组标签与文字就是元素

结构

在所有的HTML文件中最外层由标签建立，并包含两个子标签：元素为文件标题 ：元素为文件主题



：说明文件标题和文件的一些公共属性 ：文件主体

<!DOCTYPE html>

<html>

<head>

<meta charset="utf-8">

<title>HTML结构</title>

</head>

<body>

Hellow Word！

</body>

</html>

盒子模型与背景属性

一.盒子模型

1.介绍

2. 元素的总宽度和总高度
   
   二.自定义边框——border
   
   1.基本设置
   
   2.边框宽度——Border Width
   
   3.边框颜色——Border Color
   
   4.边框样式——Border style
   
   5.CSS的边宽和高度——width height
   
   三.背景——background
   
   1.背景颜色——background color
   
   2.背景图像—— background image
   
   3.背景重复—— background repeat
   
   4.背景的附件（固定与滚动）——background attachment
   
   一.盒子模型
   
   1.介绍
   
   所有HTML元素都可以视为方框。
   
   CSS边框模型代表网站的设计和布局。
   
   它由边缘（margins），边框（ borders），内边距（paddings），和内容（content）组成的。
   
   这些属性以什么的顺序工作：top->right->bottom->left。
   
   
   
   
   
   小知识：
   
   
   
   网页的每个元素都是一个盒子（box）。 CSS使用盒子模型来确定盒子有多大以及如何放置它们。
   
   框模型还用于计算HTML元素的实际宽度和高度。
   
3. 元素的总宽度和总高度
   
   （1）总宽度等于左右边缘，边框，边距相加：
   
   
   
   
   
   
   
   （2）总高度：上下相加
   
   
   
   
   
   二.自定义边框——border
   
   1.基本设置
   
   border属性允许您自定义HTML元素的边框。
   
   为了向元素添加边框，您需要指定边框的大小，样式，颜色。
   
   p {
   
      padding: 10px;    
   
      border: 5px solid green;
   
   }
   
   
   
   2.边框宽度——Border Width
   
   使用border-width属性可以 单独设置边框宽度
   
   
   
   p{
   
      padding: 10px;    
   
      border-style: solid;
   
      border-width: 2px;
   
   }
   
   
   
   3.边框颜色——Border Color
   
   可以使用颜色名称，RGB或十六进制值定义元素的边框颜色。
   
   
   
   p.first {
   
      padding: 10px;
   
      border-style: solid;
   
      border-width: 2px;
   
      border-color: blue;
   
   }
   
   
   
   小知识：除非设置border-style属性，否则所有border属性都不会起作用。
   
   
   
   4.边框样式——Border style
   
   默认值为none
   
   多种样式：dotted（点）, dashed（虚线）, double（双边框）等。
   
   p {border-style: none;}
   
   p {border-style: dotted;}
   
   p{border-style: dashed;}
   
   p{border-style: double;}
   
   p {border-style: groove;}
   
   p {border-style: ridge;}
   
   p{border-style: inset;}
   
   p{border-style: outset;}
   
   p {border-style: hidden;}
   
   
   
   
   
   
   
   5.CSS的边宽和高度——width height
   
   要设置<div>元素的总宽度和高度为100px：
   
   div {
   
      border: 5px solid green;    
   
      width: 90px;
   
      height: 90px;
   
   }
   
   
   
   框的总宽度和高度将为90px + 5px（边框）+ 5px（边框）= 100px；
   
   
   
   可以使用百分比 进行分配。
   
   div {
   
      border: 5px solid green;    
   
      width: 100%;
   
      height: 90px;
   
   }
   
   
   
   3.要设置元素的最小和最大高度与宽度，可以使用以下属性：
   
   
   
   min-width-元素的最小宽度
   
   min-height-元素的最小高度
   
   max-width-元素的最大宽度
   
   max-height-元素的最大高度
   
   p{
   
      border: 5px solid green;    
   
      min-height: 100px;       
   
   }
   
   
   
   三.背景——background
   
   1.背景颜色——background color
   
   background-color属性用来指定一个元素的背景色。
   
   
   
   列：
   
   
   
   body {
   
      background-color: #C0C0C0;
   
   }
   
   h1 {
   
      background-color: rgb(135,206,235);
   
   }
   
   p {
   
      background-color: LightGreen;
   
   }
   
   
   
   2.背景图像—— background image
   
   background-image属性中的元素可以设置一个或几个背景图像。
   
   URL指定路径的图像文件。相对路径和绝对路径均受支持。
   
   默认情况下，背景图像放置在元素的左上角，并在垂直和水平方向重复以覆盖整个元素。
   
   列;为<p>元素设置背景图片。
   
   
   
   p {
   
      padding: 30px;
   
      background-image: url("1.jpg");
   
      color: white;   
   
   }
   
   
   
   小知识
   
   
   
   要指定多个图像，只需用逗号分隔URL。
   
   
   
   3.背景重复—— background repeat
   
   repeat-x：图片延x轴复制
   
   repeat-y：图片延y轴复制
   
   Inherited：继承父级属性相同的指定值
   
   no-repeat:不重复，只有单个图片
   
   列：
   
   
   
   body {
   
      background-image: url("1.png");
   
      background-repeat: repeat-x;
   
   }
   
   p {
   
      background-image: url("1.png");
   
      background-repeat: inherit;
   
      margin-top: 100px;
   
      padding: 40px;
   
   }
   
   
   
   4.背景的附件（固定与滚动）——background attachment
   
   有效值
   
   
   
   fixed：固定背景图片
   
   scroll：向下滚动页面是，背景也随着滚动
   
   Inherit：继承
   
   列：
   
   
   
   body {
   
      background-image: url("1.png");
   
      background-repeat: no-repeat;
   
      background-attachment: scroll;
   
   }