JavaScript：JavaScript是一种web前端的描述语言，也是一种基于对象（object）和事件驱动（Event Driven）的脚本语言。它运行在客户端从而减轻服务器的负担。

js是一种解释型语言，边执行边解释，无需另外编译。

javascript的作用：

　　1. 表单验证---减轻服务器的压力；客户端表单验证即在数据送达服务端之前进行用户提交信息即时有效地验证，减轻服务器压力。即数据交互。

　　2. 制作页面特效

　　3. 动态改变页面内容

JS组成：ECMAScript、DOM、BOM

JS的引入方式和输出：

引入方式：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>第一个js</title>
  6.  
  7.     <!-- 不建议这么写 -->
  8.     <!-- <script type="text/javascript"></script> -->
  9.  
  10.     <!-- 外部式：引入一个外部JS文件
  11.         1. JS引入的时候一般放在HTML所有内容之后
  12.         2. 外部式元素内写代码块不会生效
  13.     -->
  14.     <script src="./index.js"></script>
  15. </head>
  16. <body>
  17.  
  18.     <!-- 行内式：将javascript代码直接写在标签内；DOM：document object model -->
  19.     <p id="p1" onclick="clickhandler()">123</p>
  20.  
  21. </body>
  22.  
  23. <!-- 内部式：建议引入的时候要在body之后，我们要等待所有的DOM元素加载完成之后再去执行相应的JS操作 -->
  24. <script type="text/javascript">
  25.     function clickhandler(){
  26.         // alert表示弹出警告框
  27.         // 多行注释用 /* */
  28.         alert(1);
  29.     }
  30.  
  31. </script>
  32. </html>

输出：

  1. <script type="text/javascript">
  2.     // 1.向文档内输入内容，不会覆盖原文档的内容
  3.     document.write("123");
  4.     // 2. 控制台输出 【开发者工具】
  5.     console
  6.     // 3. 向控制台抛出一条信息
  7.     console.log("233");
  8.     // 4. 向控制台抛出一个异常
  9.     console.error();
  10.     // 5. 输入一个对象的全部属性
  11.     console.dir();
  12.     // 6. 清除
  13.     console.clear();
  14.     // 每个能独立完成一个功能的代码以分号结束，这就是一个代码块
  15.  
  16.     // 7. 弹出一个带有一条指定信息的消息（警告）
  17.     alert()
  18.     // 8. 获取或者向指定元素内添加内容
  19.     innerHTML/innerText
  20.     // 9. 获取元素内所有的内容（包括元素），还可以解析内容的样式
  21.     innerHTML
  22.     // 10. 获取元素内的文本内容
  23.     innerText
  24.     // 11. 输入框prompt（相当于python中的input）,有返回值
  25.     var a = prompt("请输入你的名字")
  26.  
  27. </script>

JS的变量：

变量是用来储存信息的容器；由于JS是松散数据类型，所以变量中可以放置任何的数据类型

创建变量  储存值和代表值   （声明变量都用 var）

var a;   // 声明 创建， 此时这个变量中什么都没有，获取变量中的返回值为undefined；

= ：在JS中是赋值的意义；

+= ：在JS中是保留原来的值 上累加

一次声明多个变量，每个变量用逗号隔开；一般相同数据类型使用一个声明，如：

var a = xxx, fn = function(){}, num = 5

如下代码：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>变量的声明和定义</title>
  6. </head>
  7. <body>
  8.     <script type="text/javascript">
  9.         // 变量的声明
  10.         // 1. 先声明再定义
  11.         // 声明
  12.         var dog;
  13.         alert(dog);  // 返回“undefined”,未定义
  14.         // 定义
  15.         dog = "伟哥";
  16.         alert(dog);
  17.         alert(dog);
  18.         alert(dog);
  19.         // JS中代码的执行顺序：从上到下
  20.  
  21.         // 2. 声明时就定义
  22.         var dog2 = "伟哥2"
  23.         alert(dog2)
  24.     </script>
  25. </body>
  26. </html>

JS变量的命名规则：

　　1. 严格区分大小写

　　2. 命名时可以出现字母、数字、下划线、$，但是不能以数字开头，也不能纯数字

　　3. 不能包含关键字和保留字；关键字：var number ；除了关键字， top name也尽量不要使用

　　4. 推荐驼峰命名法：有多个有意义的单词组成名称时，第一个单词的首字母小写，其余的单词首字母大写

JS的数据类型：

  • 数字  number
  • 字符串  string
  • 布尔 boolean
  • 数组  []
  • 对象  {}
  • 空值  Null
  • 空值  Undefined

基本数据类型：数字 number、字符串 string、布尔 boolean、 null、 undefined

引用数据类型：包括对象数据类型和函数数据类型

　　对象数据类型：数组 array 、对象 object、正则 REGEXP

　　函数数据类型： function

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>5种基本数据类型</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.         // js中有两种数据类型：1. 基本数据类型；2. 引用数据类型
  11.         // 基本数据类型：number,sting,boolean,null,undefined
  12.  
  13.         // 1. 数字类型
  14.         var a = 123;
  15.         console.log(a);
  16.  
  17.         // 查看a 的数据类型，有两种写法，如下：
  18.         console.log(typeof(a))  
  19.  
  20.         // 2. 字符串类型
  21.         var s="123";
  22.         console.log(s);
  23.         console.log(typeof s)
  24.  
  25.         // 3. 布尔类型(boolean)
  26.         var b1 = true;
  27.         console.log(b1)
  28.         console.log(typeof b1)
  29.  
  30.         // 4. null(null叫空对象，是object类型)
  31.         var c1 = null;
  32.         console.log(c1)
  33.         console.log(typeof c1)
  34.  
  35.         // 5. undefined(只声明了但没有定义)
  36.         var d1;
  37.         console.log(d1)
  38.         console.log(typeof d1)
  39.  
  40.         var e1=5/0;
  41.         console.log(e1) // Infinity,无限大
  42.         console.log(typeof e1)  //number类型
  43.  
  44.     </script>
  45.  
  46. </body>
  47. </html>

浏览器效果：

运算符

JS的运算符包括：算数运算符、赋值运算符、比较运算符、逻辑运算符

算数运算符：

赋值运算符：

比较运算符

逻辑运算符：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>运算符</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 1. 赋值运算符
  12.         var money = prompt("请输入金额：");
  13.         var saveMoney = money * (1+0.02);
  14.         console.log(saveMoney)
  15.  
  16.         // 2. 算数运算符
  17.         var a = 10;
  18.         var b = 4;
  19.  
  20.         var c = a % b;  // 取余
  21.         console.log(c)
  22.  
  23.         // 2.1 复合运算符
  24.         var m=7,n=8; // 同时给多个变量赋值
  25.         n += m; // 相当于： n=m+n;
  26.         console.log(n)
  27.  
  28.         // 2.2 自增/自减1
  29.  
  30.         // x++; ：表示先赋值后++
  31.         // y = x++; ：表示先将x的值赋值给y，然后再让 x 加1（++）
  32.         var x=2;
  33.         y = x++;
  34.         console.log(x)
  35.         console.log(y)
  36.         // 所以，此时 y为2,x为3
  37.  
  38.         // ++x; ：表示先++后赋值
  39.         // y = ++x; ：表示 先让x加1（++），再将加完1的x赋值给y
  40.         var x=2;
  41.         y = ++x;
  42.         console.log(x)
  43.         console.log(y)
  44.         // 所以，此时 y为3，x也为3
  45.  
  46.         // 3. 比较运算符
  47.         // ==比较的是值的大小；===是值和类型都进行比较
  48.         console.log(5>6)
  49.         console.log(5 =="5")  // 结果为 true；隐式转换：浏览器会将数字转换成字符串
  50.         console.log(5 ==="5") // 结果为 false，因为它们数据类型不一样
  51.  
  52.         // 4. 逻辑运算符
  53.         // && 表示 and(与)；|| 表示 or (或)；! 表示 not(非)
  54.         console.log(5>6 || 1<2)  // 结果为 true
  55.         console.log(true&&false)  
  56.     </script>
  57.  
  58. </body>
  59. </html>

字符串处理

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>字符串处理</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.         // 字符串运算
  11.         var firstName = "星";
  12.         var lastName = "Li";
  13.  
  14.         // 字符串拼接
  15.         var fullName = firstName + " " + lastName;
  16.         console.log(fullName)
  17.  
  18.         var product = "化妆品";
  19.         var reason = "容易增加它的购买几率";
  20.  
  21.         var str = "和购物中心不同，去百货商场购物，进门先看到的总是" + product + "。通常商场里购买化妆品的人不如购买服装的多，将化妆品专柜设在人流量大、进入商场的必经之地，" + reason + "。";
  22.         console.log(str)
  23.  
  24.         var a1 = "1";
  25.         var a2 = "2";
  26.         console.log(a1+a2)  // 输出结果为： "12"; a1+a2还是 字符串 类型， 不是数字
  27.  
  28.         console.log(parseInt(a1+a2))  // 结果为：12（此12为数字类型）；parseInt 是一个方法：将数据类型转化为 数字类型
  29.         console.log(parseInt(a1)+parseInt(a2))  // 结果为：3 （数字类型）
  30.  
  31.         // 所以，字符串的 “+” 是 拼接的意思
  32.         // 纯数字类型的字符串可以进行 算数运算（加减乘除等）
  33.  
  34.         var b1 = "one",b2="two";
  35.         console.log(b1*b2)  // 输出结果为：NaN （全称 not a number）；但 NaN的数据类型却是 number 数据类型
  36.  
  37.     </script>
  38. </body>
  39. </html>

数据类型的转换

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>数据类型的转换</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 1. 将数字类型 转换为 字符串类型
  12.  
  13.         var n1 = 123;
  14.         var n2 = "4";
  15.         var n3 = n1+n2;
  16.         console.log(n3)  // 输出结果为 "1234"
  17.         console.log(typeof n3)  //数据类型为 字符串
  18.  
  19.         // 强制类型转换:1. String()  2. toString()
  20.         // String() 是一种方法：将数据类型转换为 string 类型
  21.         var str1 = String(n1);
  22.         console.log(str1)
  23.         console.log(typeof str1)
  24.  
  25.         var num = 234;
  26.         console.log(num.toString())
  27.         console.log(typeof num.toString()) // string
  28.         console.log(typeof num)  // number
  29.  
  30.         // 2. 将字符串类型 转换成 数字类型：1. Number(); 2. parseInt();  3. parseFloat()
  31.         var strNum = "789.123bnaoi";
  32.         var num2 = Number(strNum);
  33.         console.log(num2)  // NaN
  34.         console.log(typeof num2)  // number
  35.  
  36.         // parseInt() 可以解析一个字符串，并且返回一个整数
  37.         console.log(parseInt(strNum))  // 789
  38.         console.log(typeof parseInt(strNum))  //number
  39.  
  40.         // parseFloat()可以解析一个字符串并返回一个 浮点数
  41.         console.log(parseFloat(strNum))  // 789.123
  42.         console.log(typeof parseFloat(strNum))  // number
  43.  
  44.         // 3. 布尔类型；在JS中，所有的数据类型都可以被归为 布尔类型(boolean)
  45.         var m1 = "123";
  46.         console.log(Boolean(m1))  // true
  47.  
  48.         var m2 = 0;
  49.         console.log(Boolean(m2))  // false
  50.         var m3 = "";
  51.         console.log(Boolean(m3))  // false
  52.         var m4 = NaN;
  53.         console.log(Boolean(m4))  // false
  54.         var m5;  // 只声明未赋值； 相当于 undefined
  55.         console.log(Boolean(m5))  // false
  56.         var m6 = null;
  57.         console.log(Boolean(m6)) // false
  58.         var m7 = undefined;
  59.         console.log(Boolean(m7))  // false
  60.  
  61.         var m8 = -1;
  62.         console.log(Boolean(m8))  // true
  63.         var m9 = Infinity;
  64.         console.log(Boolean(m9)) // true
  65.  
  66.     </script>
  67.  
  68. </body>
  69. </html>

流程控制语句

if语句：

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>流程控制语句if</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         var goal = 20;
  12.         if(goal>=20){
  13.             console.log("吃鸡成功，大吉大利")
  14.         }else{
  15.             console.log("下次继续努力")
  16.         }
  17.  
  18.         var n = 10;
  19.         if (n<5) {
  20.             console.log("小于5")
  21.         }else if (n<10) {  //此处不能写成 5<=n<10
  22.             console.log("5到10之间")
  23.         }else if (n<15) {  //此处不能写成 10<=n<15
  24.             console.log("10到15之间")
  25.         }else{
  26.             console.log("多于15")
  27.         }
  28.         // 注意：浏览器解析代码的顺序是：从上往下，从左往右
  29.  
  30.         var math = 90;
  31.         var eng = 85;
  32.         var sum = 485;
  33.         // 逻辑 与
  34.         if(sum>400 && math>85){
  35.             console.log("被清华录取")
  36.         }else{
  37.             alert("没考上清华")
  38.         }
  39.         // 逻辑 或
  40.         if (sum>400 || eng >90) {
  41.             alert("被复旦录取")
  42.         }
  43.  
  44.         // if语句中能进行运算
  45.         if (sum>500 || (math+eng)>170) {
  46.             console.log(233)
  47.         }
  48.  
  49.     </script>
  50.  
  51. </body>
  52. </html>

switch语句：

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>switch语句</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         var gameScore = "666";
  12.  
  13.         // gameScore 表示比较对象
  14.         switch (gameScore) {
  15.  
  16.             // case 表示一个条件，满足这个条件就会走进来执行后面的代码（类似于打开了开头）；遇到break跳出
  17.             case "good":
  18.             console.log("玩的good")
  19.             // break 表示退出
  20.             break;
  21.             case "better":
  22.             console.log("玩的better")
  23.             break;
  24.  
  25.             // default 表示不做比较了（相当于if...else...语句中的else）
  26.             default:
  27.             console.log("很遗憾，你出局了")
  28.             break;
  29.  
  30.         }
  31.  
  32.     </script>
  33.  
  34. </body>
  35. </html>

while循环语句：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>while循环</title>
  6. </head>
  7. <body>
  8.     <script type="text/javascript">
  9.  
  10.         // while循环：1. 初始化循环变量； 2. 判断循环条件； 3. 更新循环变量
  11.         var i = 1;
  12.         while(i<=9){
  13.             console.log(i)
  14.             i += 1;
  15.         }
  16.  
  17.         // 练习：将1-100之间的所有3的倍数 输出出来
  18.         var n = 1;
  19.         while(n<=100){
  20.             if (n%3===0) {
  21.                 console.log(n)
  22.             }
  23.             n++;
  24.         }
  25.     </script>
  26.  
  27. </body>
  28. </html>

do...while... 循环语句

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>do-while语句</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // do while循环：1. 初始化循环变量；2.判断循环条件；3.更新循环变量
  12.         // 不管有没有满足while中的条件，do里面的代码都会执行一遍
  13.         var i = 3;
  14.         do{
  15.             console.log(i)
  16.             i++;
  17.         }while(i<10)
  18.     </script>
  19.  
  20. </body>
  21. </html>

for 循环语句：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>for循环语句</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // for(声明、初始化变量;循环变量;更新循环变量){执行}
  12.         for(var i=1; i <= 10; i++){
  13.             console.log(i)
  14.         }
  15.  
  16.         // 输出1-100之间的偶数
  17.         for (var i=1;i<=100;i++) {
  18.             if (i%2 == 0) {
  19.                 console.log(i)
  20.             }
  21.         }
  22.  
  23.         // 计算1-100之间所有数的和
  24.         var sum=0;
  25.         for (var i=1; i<=100; i++){
  26.             sum += i;
  27.         }
  28.         console.log(sum)
  29.  
  30.         // 在浏览器上输出如下样式：（每行6个*，总共3行）
  31.         // ******
  32.         // ******
  33.         // ******
  34.  
  35.         // document.write() 表示 往浏览器 上写
  36.         for (var i=1; i<=3; i++){ // i表示行，用于换行
  37.             for(var j=1;j<=6;j++) { // j代表水平方向上的个数
  38.                 document.write("*")
  39.             }
  40.             document.write("<br>")  // 写完一行就换行
  41.         }
  42.         // 两个for循环的嵌套
  43.  
  44.     </script>
  45.  
  46. </body>
  47. </html>

练习：利用 for 循环 画出三角形

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>for循环之三角形</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 直角三角形
  12.         for (var i=1; i<=6;i++){
  13.  
  14.             for(var j=1;j<=i;j++){
  15.                 document.write("*")
  16.             }
  17.  
  18.             document.write("<br>")
  19.         }
  20.  
  21.         // 等边三角形
  22.  
  23.         for (var i=1;i<=6;i++){
  24.             for(var k=i;k<6;k++){ // 空格数
  25.                 document.write("&nbsp;")
  26.             }
  27.  
  28.             for (var v=1; v<= 2*i-1; v++){  // 控制 “*” 个数
  29.                     document.write("*")
  30.             }
  31.  
  32.             document.write("<br>")
  33.         }
  34.  
  35.     </script>
  36.  
  37. </body>
  38. </html>

常用内置对象

内置对象就是ECMAScript提供出来的一些对象，对象都有相应的属性和方法

数组：Array

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>数组</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 创建数组
  12.         // 1. 字面量方式创建(推荐使用这种方式)
  13.         var colors = ["red","color","yellow"];
  14.         console.log(colors)
  15.         // 创建空数组（推荐）
  16.         var emptyArray = [];
  17.  
  18.         // 2. 使用构造函数的方式创建 ： 使用关键词 new 对 构造函数 进行创建对象
  19.         var color2 = new Array();   // new Array() 也是创建一个空数组
  20.         var color3 = new Array("black","red","blue");
  21.         console.log(color3)
  22.  
  23.         // 数组赋值
  24.         var arr = [];
  25.         arr[0]=123;
  26.         arr[1]="哈哈";
  27.         arr[2]="嘿嘿";  // []中的数即下标（索引），相当于python列表中的索引
  28.         console.log(arr)
  29.  
  30.         // 数组的取值
  31.         console.log(arr[2])  // 通过下标取到相应的值
  32.         console.log(arr.length)  //通过 lenght 这个属性 取到数组 的长度（元素个数）
  33.  
  34.         // 遍历数组
  35.         for (var i=0;i<arr.length;i++){
  36.             console.log(arr[i])
  37.         }
  38.  
  39.     </script>
  40.  
  41. </body>
  42. </html>

浏览器效果：

数组常用方法：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>数组常用方法</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 1. 数组的合并： concat
  12.         var north = ["北京","天津","山东"];
  13.         var south = ["东莞","深圳","上海"];
  14.  
  15.         var newArr = north.concat(south);
  16.         console.log(newArr)
  17.  
  18.         // 2. 将数组转化成字符串： .toString()
  19.         var score = [98,76,63,100,0];
  20.  
  21.         // toString() : 直接转化为字符串，每个元素之间会用逗号隔开
  22.         var str = score.toString();
  23.         console.log(str)
  24.         // join() 方法： 将数组中的元素使用指定的字符串连接起来，形成一个新的字符串
  25.         var str2 = score.join("|")
  26.         console.log(str2)
  27.  
  28.         // 3. 通过内容查找下标
  29.         // 3.1 indexOf() ： 正向查找（返回第一个索引）
  30.         // 如果查找的值在数组中不存在则返回 -1
  31.         var index = score.indexOf(76);
  32.         console.log(index)  // 输出：1
  33.         // 3.2 lastIndexOf() ：反向查找（返回指定元素最后一个的索引）
  34.         var lasIndex = score.lastIndexOf(76);
  35.         console.log(lasIndex)  // 输出：1
  36.  
  37.         // 4. 数组排序
  38.         var names = ["alex","neo","ago","egon"];
  39.  
  40.         // 4.1 反转排序： reverse()  （对该数组排序，并且有返回值）
  41.         var reNames = names.reverse();
  42.         console.log(reNames)  //  ["egon", "ago", "neo", "alex"]
  43.         console.log(names)  //  ["egon", "ago", "neo", "alex"]
  44.         // 4.2 sort()：按照26个字母排序（从a到z）（对该数组排序，并且有返回值）
  45.         var sortNames = names.sort();
  46.         console.log(sortNames)  // ["ago", "alex", "egon", "neo"]
  47.         console.log(names)  // ["ago", "alex", "egon", "neo"]
  48.  
  49.         // 移除元素和添加元素
  50.         // 4.1 数组第一个
  51.         // 4.1.1 移除元素
  52.         // shift() ：移除数组的第一个元素，并将这个元素返回 (用法类似于python中的 list.pop()方法)
  53.         var firstName = names.shift()  // shift()会将该数组的第一个元素删除，names.shift()的返回值就是删除的第一个元素
  54.         console.log(firstName) // ago
  55.         console.log(reNames)  // ["alex","egon","neo"]
  56.         console.log(sortNames)  // ["alex","egon","neo"]
  57.         console.log(names)  // ["alex","egon","neo"]
  58.         // names,reNames,sortNames的关系是： ===
  59.  
  60.         // 4.1.2 unshift() ： 向数组的开头添加一个或多个元素，并返回新的长度（length）
  61.         names2 = ["abc","mike","alice"];
  62.         var newLength = names2.unshift("shanshan","wxx");
  63.         console.log(newLength) // 5
  64.         console.log(names2)
  65.  
  66.         // 4.2 数组最后一个
  67.         // 4.2.1 push()  ： 往数组的末尾添加一个或者多个元素，并返回新的长度
  68.         var newLength2 = names2.push("老村长","丫丫")
  69.         console.log(newLength2)
  70.         console.log(names2)
  71.         // 4.2.2 pop() ：删除数组的最后一个元素，并将该元素返回
  72.         var a = names2.pop()
  73.         console.log(a)
  74.         console.log(names2)
  75.  
  76.         // 练习：把下面的字符串反转 （前端常见面试题）
  77.         var str = "hello world"
  78.         console.log(str.split("").reverse().join(""))  // 输出结果：dlrow olleh
  79.         // str.split() 是 sting 的一种方法：将字符串分裂成数组
  80.  
  81.     </script>
  82.  
  83. </body>
  84. </html>

JavaScript函数

函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>函数</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 1. 函数的创建；
  12.         // 1.1 JS函数的声明；注意：有函数的声明就一定有调用
  13.         function add(){
  14.             alert("函数被调用了")
  15.             // 函数体；执行一些操作
  16.         }
  17.  
  18.         // 1.2 函数的调用
  19.         add()
  20.  
  21.         // 2. 声明函数时带参数
  22.         function add2(a,b){  // a，b是形参
  23.             alert(a+b)
  24.         }
  25.         add2(3,4)
  26.  
  27.         // 3. 声明函数时有返回值
  28.         function add3(x,y){
  29.             return x+y;  // return 返回值
  30.         }
  31.  
  32.         var sum = add3(4,5)  // 有返回值就需要声明一个变量去接收这个返回值
  33.         console.log(sum)
  34.  
  35.     </script>
  36.  
  37. </body>
  38. </html>

对象：object 和 构造函数

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>object构造函数</title>
  5. </head>
  6. <body>
  7.  
  8.     <script type="text/javascript">
  9.  
  10.         //  对象的创建
  11.         // 1 字面量方式创建 （推荐使用这种方式）
  12.         // 1.1 key:value形式；value可以是js中的任意的数据类型
  13.         var stu = {
  14.             name:"alex",
  15.             age:"52",
  16.             fav:"鸡汤"
  17.         }
  18.         console.log(stu)
  19.         console.log(window)  // window也是个对象
  20.  
  21.         // 1.2 点语法：包括 get方法和 set方法
  22.         var n = stu.name   //get方法；get之后需要声明一个变量去接收这个值
  23.         console.log(n)
  24.         stu.age = 62;  // set方法
  25.         console.log(stu.age)
  26.  
  27.         // 2 使用Object（）创建对象
  28.         // Object() 表示 构造函数；特点：1. 首字母大写； 遇到构造函数，要想创建对象， new 一个
  29.         var obj = new Object();  // 创建一个 新的空对象；Object（）是一个构造函数
  30.         console.log(obj)  // {}
  31.         // 赋值
  32.         obj.name = "xiaomage";
  33.         console.log(obj)
  34.  
  35.         //  3. 使用自定义的构造函数创建对象
  36.         // -------------构造函数---------------
  37.         // 构造函数的注意点：
  38.         //     1. 函数名要大写
  39.         //        2. 构造函数不需要return
  40.         //     3. 要为对象添加成员变量（即属性值）；通过this添加（this表示当前对象），如：this.name = "neo"
  41.         // 声明
  42.         var Stu = function(){  // function()中能传入形参，因为 function(){}是普通声明函数的方式； Stu也是一个对象；
  43.             // 为Stu这个对象添加成员变量（属性（和方法））
  44.             this.name = "neo";
  45.             this.age = 22; //  name和age是属性
  46.             this.fav = function(){   // fav是一种方法
  47.                 console.log("泡妹子")
  48.  
  49.             }
  50.         }
  51.         // 利用new和Stu 去 创建对象
  52.         var s = new Stu();
  53.         console.log(s)  
  54.  
  55.         var s1 = new Stu(); // 声明时如果function里面带参数， new的时候也要带参数
  56.         console.log(s1)  // s 和 s1 虽然方法和属性都一样，但它们的内存空间是不同的
  57.         //  上述方法的弊端：每次new一个对象，里面的成员变量都一样；所以上述方法不推荐使用
  58.  
  59.         // 推荐使用的构造函数的方式 ，如下（这种方式很常见）
  60.         function Animal(){ // Animal()中可传入参数
  61.             // 函数体；添加成员变量
  62.             this.name = "abx";  // this 表示当前的对象
  63.             this.age = 12;
  64.             /*
  65.             this.fav = function(){
  66.                 console.log(this.age)
    　　　　　　　}
  67.             */  //  方法通常写在外面，如下所示
  68.         }
  69.         Animal.prototype.fav = function(){  // 方法用这种形式写在外面；给Animal添加了一个fav方法
  70.             console.log(this.age)
  71.  
  72.         }
  73.         var a = new Animal();  // 构造函数创建实例
  74.         a.fav();  // a 也会有 fav这个方法；因为继承
  75.  
  76.     </script>
  77.  
  78. </body>
  79. </html>

String_Number对象

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>String_Number</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 内置对象
  12.  
  13.         // 1. String  字符串对象
  14.         var str = "hello world";
  15.         // 1.1 长度
  16.         console.log(str.length)  // 11；该字符串的长度
  17.  
  18.         // 1.2 转成大写
  19.         var uppperStr = str.toUpperCase()  // 将字符串变成大写
  20.         console.log(uppperStr)  // HELLO WORLD
  21.         console.log(str)  //  hello world； toUpperCase()只是返回了str的全大写，并没有对str做任何修改
  22.         // 1.3 转成小写
  23.         console.log(uppperStr.toLowerCase())  // hello world
  24.  
  25.         // 1.4 分割字符串：split("",number) ：第一个参数表示 分割符，第二个表示 返回数组的最大长度
  26.         var newArr = str.split(" ",1)
  27.         console.log(newArr) // ["hello"]
  28.  
  29.         // 1.5 截取字符串： substring(index1,index2) ：截取index1 到 index2 之间的内容，也是顾头不顾尾
  30.         var a = str.substring(2,6)
  31.         console.log(a) //"llo "
  32.         console.log(str)
  33.  
  34.         // 2. Number 数字对象
  35.         // 2.1 toString() ：将 number类型转换成字符串类型
  36.         var num = 123.32456;
  37.         var numStr = num.toString();
  38.         console.log(typeof numStr)
  39.  
  40.         // 2.2 toFixed(number) ：四舍五入；其中的number表示保留小数点后多少位
  41.         var numRound = num.toFixed(3)
  42.         console.log(numRound)  // 123.325
  43.  
  44.     </script>
  45.  
  46. </body>
  47. </html>

Date对象

Date对象用于处理日期和时间

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>date的使用</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // 创建日期对象
  12.         var myDate = new Date();
  13.  
  14.         // dateObject.getDate() ：获取一个月中的某一天（几号）
  15.         console.log(myDate.getDate())  // 3
  16.  
  17.         // Date() ： 获取当天的时间（年月日时时分秒）
  18.         console.log(Date()) // Thu May 03 2018 18:18:46 GMT+0800 (中国标准时间)
  19.  
  20.         // dateObject.getMonth() ：获取一年中的某一个月（0-11，0表示1月）
  21.         console.log(myDate.getMonth())  // 4
  22.         console.log(myDate.getMonth()+1)  // 准确的月份; 5
  23.  
  24.         // dateObject.getDay() ：获取一周中的某一天（0-6，0表示周日）
  25.         console.log(myDate.getDay()) // 4
  26.  
  27.     </script>
  28.  
  29. </body>
  30. </html>

Date其它常用的方法：

Math对象

Math对象用于执行数学任务

注意：Math对象并不像Date和String那样是对象的类，因此没有构造函数 Math()，像Math.sin()这样的函数只是函数，并不是某个对象的方法；通过把Math作为对象使用就可以调用其所有属性和方法

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>Math用法</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         // Math.ceil(x) ：可对一个数进行上舍入；返回值：大于等于x，并且与它最接近的整数
  12.         var x = 1.234;
  13.         var a = Math.ceil(x);  // 天花板函数
  14.         console.log(a)  // 2
  15.  
  16.         // Math.floor(x) ：可对一个数进行下舍入；返回值：小于等于x，且与x最接近的整数
  17.         var b = Math.floor(x);  // 地板函数
  18.         console.log(b)  // 1
  19.  
  20.         // 最大值、最小值
  21.         console.log(Math.max(2,5))
  22.         console.log(Math.min(2,5))
  23.  
  24.         // Math.random() ： 0~1之间的随机数（包含0但不包含1）
  25.         var ran = Math.random();
  26.         console.log(ran)
  27.  
  28.         // 100~200之间的随机数
  29.         var c = 100 + (Math.random()*100;  // 不能直接写成： Math.random()*200
  30.         console.log(c)
  31.         // 公式：min ~ max 之间的随机数
  32.         // min + Math.random()*(max - min)
  33.  
  34.     </script>
  35.  
  36. </body>
  37. </html>

定时器

1、setInterval()：按照指定 的周期（以毫秒计）来调用函数或计算表达式；

setInterval（）方法会不停地调用函数，直到遇到clearInterval（）被调用或窗口被关闭。由setInterval（）返回的ID值可用作clearInterval（）方法的参数

2、setTimeout() ： 用于在指定的毫秒数后调用函数或计算表达式

提示：setTimeout（）只执持code一次

示例代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>定时器</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.         // 定时器是windows的方法
  11.         // 1. window.setInterval()
  12.         // 1s = 1000ms
  13.         var n = 0;
  14.         var codeId = null;  // 先声明 codeId = null；通过这种方式，让codeId变成全局变量,这样在任意函数体里面都能被调用了
  15.         codeId = setInterval(function(){ // 返回一个ID
  16.             n++;
  17.             console.log(n)
  18.         },1000);
  19.  
  20.         // 2. window.setTimeout()
  21.         setTimeout(function(){
  22.             console.log(codeId)
  23.             window.clearInterval(codeId);  //  5秒之后关掉上面的 setInterval()
  24.         },5000);
  25.  
  26.     </script>
  27.  
  28. </body>
  29. </html>

正则表达式

正则表达式的创建和常用方法：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>正则表达式</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.         // 正则：对象：RegExp  正则表达式：检索字符串，用来规定文本搜索的内容
  11.  
  12.         // 1. ----------------------创建正则表达式------------------
  13.         // 1.1 构造函数创建： new RegExp("检测的文本","修饰符");  i：不区分大小写； g：全局匹配
  14.         var str = "luffy 2018";
  15.         var reg = new RegExp("l","ig");
  16.         console.log(reg)
  17.  
  18.         // 1.2 字面量方式创建（推荐使用这种方式）
  19.         var reg1 = /y/ig;  // 不区分大小写，全局匹配； 是一种匹配规则
  20.         console.log(reg1)
  21.  
  22.         // 2.---------------正则对象提供的检索方式------------
  23.         // 2.1 test() ： 检测字符串中是否包含定义字符模式，返回布尔值；用于检测，如检测邮箱是否正确
  24.         // 要检索的字符在字符串中存在：true
  25.         // console.log(reg1.test(str))  // true
  26.  
  27.         // 2.2 exec()：用来检索字符串中正则表达式的匹配
  28.         // 如果匹配到了，那么就返回一个存放有结果的数组，如果没有匹配到就返回一个null
  29.         console.log(reg1.lastIndex); // 0；reg1.lastIndex ：用于保存一次匹配时开始的下标（匹配到的下一个索引）；lastIndex用于test()和exec()，前提是reg1中有 g(全局匹配)
  30.         console.log(reg1.exec(str)); // ["y", index: 4, input: "luffy 2018", groups: undefined]
  31.         console.log(reg1.lastIndex);  // 5
  32.  
  33.         // 3.---------------常用方法------------------
  34.         // 3.1 match方法,匹配查找（所有的都找到） ：字符串.match(正则)
  35.         var str = "hello world";
  36.         var reg = /o/g;
  37.         // 使用正则表达式模式对字符串执行查找，并将包含查找的结果作为数组返回
  38.         console.log(str.match(reg)); // ["o", "o"]
  39.  
  40.         // 3.2 replace 替换物 ：str.replace(被替换的,替换的)
  41.         // 补充：字符串也有replace方法，如上所示
  42.         // console.log(str.replace(reg,"*"))  // hell* w*rld
  43.  
  44.         // 3.3 search() ：返回第一个查询字符在字符串中所在的位置（索引，下标）；
  45.         console.log(str.search(reg)); // 4
  46.  
  47.         // 3.4 split() 分割 ： 以匹配的规则进行分割
  48.         console.log(str.split(reg));  // ["hell", " w", "rld"]
  49.  
  50.     </script>
  51.  
  52. </body>
  53. </html>

浏览器效果如下：

lastIndex属性可参考：http://www.jb51.net/article/120608.htm

正则表达式的匹配规则：元字符

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <title>元字符</title>
  6. </head>
  7. <body>
  8.  
  9.     <script type="text/javascript">
  10.  
  11.         window.onload = function(){
  12.             // 元字符：匹配的规则
  13.             // 1. 单个字符和数字
  14.             // 1.1 . (单个点)：匹配除换行符以外的任意单个字符；
  15.             var str = "luffyCity 2018";
  16.             var reg = /./g;
  17.             console.log(reg.exec(str));  // ["l", index: 0, input: "luffyCity 2018", groups: undefined]
  18.  
  19.             // 1.2 如果想让特殊字符不带语法含义， 转义：\ ；如： \. 表示匹配. ；
  20.             str = "www.baidu.com";
  21.             var reg = /www\......\.com/g;
  22.             console.log(reg.exec(str))  // ["www.baidu.com", index: 0, input: "www.baidu.com", groups: undefined]
  23.  
  24.             // 1.3 [] ：匹配[]里面的任意一个字符
  25.             var str1 = "hello";
  26.             var reg1 = /[a-zA-Z0-9]/g;  // 一个
  27.             console.log(reg1.exec(str1))  // ["h", index: 0, input: "hello", groups: undefined]
  28.             var str2 = "A123456";
  29.             var reg2 = /[0-9][0-9][0-9]/g;  // [0-9][0-9][0-9] 匹配三个，但这三个是一个整体
  30.             console.log(reg2.exec(str2)); // ["123", index: 1, input: "A123456", groups: undefined]
  31.  
  32.             // 1.4 [^] ：所有不在这个范围内的字符（非）
  33.             var str3 = "aBd123";
  34.             var reg3 = /[^a-z][^A-Z]/g;
  35.             console.log(reg3.exec(str3)); // ["Bd", index: 1, input: "aBd123", groups: undefined]
  36.  
  37.             // 1.5 \d  ：匹配数字； \D ：匹配非数字
  38.             var str4 = "web";
  39.             var reg4 = /\d/g;
  40.             var reg5 = /\D/g;
  41.             console.log(reg4.exec(str4));  // null
  42.             console.log(reg5.exec(str4));  // w
  43.  
  44.             // 1.6 \w ：匹配数字、字母、下划线 ； \W ：匹配数字、字母、下划线 以外的任意字符；
  45.  
  46.             // 1.7 \s ：匹配空格； \S ：匹配非空格
  47.             // trim() ：去除字符串前后端的空格；
  48.             var str5 = "luffy";
  49.             var reg8 = /\s/g;
  50.             var reg9 = /\S/g;
  51.             console.log(reg8.exec(str5)); // " "
  52.             console.log(reg9.exec(str5)); // l；exec()接着上面exec()的索引往下执行；
  53.  
  54.             // 1.8 ^ ：以什么开头；  $ ：以什么结尾
  55.             var str6 = "www.baidu.com";
  56.             var reg10 = /^www/g;
  57.             console.log(reg10.exec(str6)); // www
  58.  
  59.             var reg11 = /^www\......\.com$/g;
  60.             console.log(reg11.exec(str6)) // com
  61.  
  62. //  --------------------------------------------------------------------------------------------------------
  63.  
  64.             // 2 重复的字符
  65.             // 2.1  ? ：匹配前面的字符0个或1个；
  66.             var str7 = "A123webr4456498ere";
  67.             var reg12 = /[0-9]?/g;
  68.             console.log(reg12.exec(str7))  // ["", index: 0, input: "a123webr4456498ere", groups: undefined]
  69.  
  70.             // 2.2 * ：匹配0个或任意多个字符；
  71.             var reg13=/[a-z]*/g;
  72.             console.log(reg13.exec(str7));  // ["", index: 0, input: "A123webr4456498ere", groups: undefined]
  73.  
  74.             // 2.3 + ： 至少匹配一次；
  75.             var reg14 = /\d+/g;
  76.             console.log(reg14.exec(str7))  // 123
  77.  
  78.             // 2.4、 ｛10｝ ： 匹配连续的10个字符
  79.             var stra = "13249874165";
  80.             // 以1开头后面连续匹配10个数字结尾
  81.             var rega = /^1\d{10}$/g;  // so, 总共会有11位
  82.             console.log(rega.exec(stra))  // 13249874165
  83.  
  84.             // 2.5、 {min,max} ：最少min个，最多max个
  85.             var strb = "rng";
  86.             // 以大小写英文字母开头 并且最少2个最多3个字母结尾
  87.             var regb = /^[A-Za-z]{2,3}$/g;
  88.             console.log(regb.exec(strb)); // rng
  89.  
  90.             // 2.6、 | ：或者
  91.             var strc = "www.google";
  92.             var regc = /www.baidu|google|yahoo/g;
  93.             console.log(regc.exec(strc));  // ["google", index: 4, input: "www.google", groups: undefined]
  94.  
  95.             // 2.7、() ：分组
  96.             var regc1 = /(baidu)|(google)|(luffycity)/g;
  97.             console.log(regc1.exec(strc));  // (4) ["google", undefined, "google", undefined, index: 4, input: "www.google", groups: undefined]
  98.  
  99.             // 获取匹配的字符串
  100.             console.log(RegExp.$1); // 获取第一组；// 结果： 无
  101.             console.log(RegExp.$2); // 获取第二组；// 结果：google
  102.             console.log(RegExp.$3); // 获取第三组；// 结果： 无
  103.  
  104.             var str8 = "helloworld";
  105.             var reg15 = /(hello)(world)/g;
  106.             console.log(reg15.exec(str8));  // helloworld
  107.             console.log(RegExp.$1); // hello
  108.             // 将分组后的匹配 调换顺序
  109.             console.log(str8.replace(reg15,"$2 $1"));  // world hello
  110.  
  111. // ---------------------------------------------------------------------------------
  112.             // 练习
  113.             // 1. 检索字符串中是否不包含字母
  114.             var strt1 = "12";
  115.             var regt1 = /[^a-zA-Z]/g;
  116.             if (regt1.test(strt1)){
  117.                 console.log("不包含");
  118.             }else{
  119.                 console.log("包含");
  120.             }
  121.  
  122.             // 2. 利用正则表达式去除字符串两端的空格
  123.             var strt2 = "         hello world          ";
  124.             var regt2 = /^\s+/g;
  125.             var strt3 = strt2.replace(regt2,"") // 把首部的空格替换成空字符串
  126.             var regt3 = /\s+$/g;
  127.             var strt4 = strt3.replace(regt3,""); // 把尾部的空格替换成空字符串
  128.             console.log(strt4)
  129.  
  130.             // 3. 电话号码
  131.             // 验证规则：区号+号码，区号以0开头，3位或4位
  132.             //                  号码由7位或8位数字组成
  133.             //                 区号与号码之间可以无连接符，也可以“-”连接
  134.             function checkPhone(str) {
  135.                 var regt4 = /^0\d{3,4}-?\d{7,8}$/;
  136.                 if (regt4.test(str)){
  137.                     console.log("正确")
  138.                 }else{
  139.                     console.log("错误")
  140.                 }
  141.             }
  142.             checkPhone("01231234567")  // 调用函数
  143.  
  144.         }
  145.     </script>
  146.  
  147. </body>
  148. </html>

前端开发：JavaScript---ECMAScript的更多相关文章

  1. 1+x 证书 Web 前端开发 JavaScript 专项练习

    官方QQ群 1+x 证书 Web 前端开发 JavaScript 专项练习 http://blog.zh66.club/index.php/archives/198/

  2. 第十一章 前端开发-JavaScript

    第十一章 前端开发-JavaScript 11.3.1 js引入方式 行内样式 <p id="" class="" style="" ...

  3. 前端开发 JavaScript 干货知识点汇总

    很多初学的朋友经常问我,前端JavaScript都需要学习哪些东西呀?哪些是JavaScript的重点知识啊? 其实做前端开发工程师,所有的知识点都是我们学习必备的东西,只有扎实的技术基础才是高薪的关 ...

  4. 前端开发 - JavaScript - 总结

    一.JavaScript的特征 javaScript是一种web前端的描述语言,也是一种基于对象(object)和事件驱动(Event Driven)的.安全性好的脚本语言.它运行在客户端从而减轻服务 ...

  5. 前端开发JavaScript入门——JavaScript介绍&基本数据类型

    JavaScript 诞生于1995年,它的出现主要是用于处理网页中的 前端验证. • 所谓的前端验证,就是指检查用户输入的内容是否符合一定的 规则. • 比如:用户名的长度,密码的长度,邮箱的格式等 ...

  6. 前端开发 JavaScript 规范文档

    一,规范目的 为提高团队协作效率,便于前端后期优化维护,输出高质量的文档. 二.基本准则 符合web标准,结构表现行为分离,兼容性优良.页面性能方面,代码要求简洁明了有序, 尽可能的减小服务器负载,保 ...

  7. 15款不容错过的前端开发Javascript和css类库 - 2017版本~

    前端的JS和CSS类库日新月异, 在今天这篇介绍中,我们将精挑细选15款超棒的JS/CSS类库, 希望大家在开发过程中会觉得有帮助~ Core UI 基于Bootstrap4的一套UI类库, Core ...

  8. Web前端开发JavaScript基础

    JavaScript 一种直译式脚本语言,是一种动态类型.弱类型.基于原型的语言,内置支持类型,它的解释器被称为JavaScript引擎,是浏览器的一部分,并且是被广泛用于客户端的脚本语言,JavaS ...

  9. 前端开发JavaScript清除浏览器缓存的方法

    查看和删除浏览器缓存的方法=====>打开 最近在开发项目中发现有时候总要频繁地清除浏览器缓存,不然总是显示的过时的信息 浏览器缓存有利有弊,有些数据需要缓存下来使得页面打开更快提高网站性能,但 ...

  10. 前端开发 - JavaScript 词法分析

    JavaScript代码运行前有一个类似编译的过程即词法分析,词法分析主要有三个步骤: 1.分析函数的参数 2.分析函数的变量声明 3.分析函数的函数声明表达式 具体步骤如下: 函数在运行的瞬间,生成 ...

随机推荐

  1. 3、InputStream

    package com.io.file; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoun ...

  2. Join方法，yield方法，线程的优先级

  3. python vs java的rsa加密

    首先:java的加密解密模块需要更加精细的算法细节指定 java的加密方式 javax.crypto.Cipher,定义的获取方式 tatic Cipher getInstance(String tr ...

  4. vim插件minibuf配置

    1.去下载网站下载minibufexpl.vim文件放入到~/vim/plugins中,有的系统路径是~/.vim/plugins; 下载网址如下 https://www.vim.org/script ...

  5. Scala基础篇-04 try表达式

    1.try表达式 定义 try{} catch{} finally{} //例子 try{ Integer.parseInt("dog") }catch { }finally { ...

  6. 简述SVN服务器配置和客户端操作

    有关SVN服务器的搭建见:http://www.cnblogs.com/DwyaneTalk/p/3997688.html 搭建好环境之后,服务器端需要完成如下操作: 1.需要新建Repository ...

  7. 浅谈Key-value 存储——SILT

    摘要:本文以文章SILT: A Memory Efficient High Performance Key-Value Store 为基础,探讨SILT存储系统是如何实现内存占用低和高性能的设计目标, ...

  8. iisexpress局域网内调试网站

    1.找到IISExpress目录 IISExpress\config\applicationhost.config(注:如果使用vs2015则更改解决方案目录下的.vs文件夹中的该文件) <si ...

  9. zabbix_sender

    转载一个python写的zabbix sender脚本 #!/usr/bin/env python # -*- coding: utf-8 -*- import socket import struc ...

  10. 迅为iMX6开发板支持单核,双核,四核处理器，为客户产品选择提供灵活性

    本文转自迅为:http://topeetboard.com 店铺:https://arm-board.taobao.com 处理器:Freescale Cortex-A9 四核 i.MX6Q 主频 1 ...