Linux运维之路

Posted _枝桠。

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux运维之路相关的知识，希望对你有一定的参考价值。

JS的变量与保留字

一、变量

  • 在js中使用var关键字，进行变量的声明,（var是英语“variant”变量的缩写）注意 分号作为一句代码的结束符
  • 声明变量时可以不用var. 如果不用var那么它是全局变量
  • 命名方式：Pascal标记法命名的变量前附加一个小写字母（或小写字母序列），说明该变量的类型。例如，i 表示整数，s 表示字符串，如下所示“ Var iMySalary = 1000000, sMyInfo = "hello";
<script type="text/javascript">
//var还可以一次声明多个变量，变量之间用,逗号隔开。
var x,y;
var x = 5;//声明变量x并将5赋值给x

var x; //声明变量x
x = 5; //给变量x赋值

</script>
View Code

二、保留字

abstract、boolean、byte、char、class、const、debugger、double、enum、export、extends、final、float、goto implements、import、int、interface、long、native、package、private、protected、public、short、static、super、synchronized、throws、transient、volatile、

三、语言类型

  • 静态类型语言

    一种在编译期间就确定数据类型的语言。大多数静态类型语言是通过要求在使用任一变量之前声明其数据类型来保证这一点的。Java 和 C 是静态类型语言。

  • 动态类型语言

    一种在运行期间才去确定数据类型的语言，与静态类型相反。VBScript 和 Python 是动态类型的，因为它们确定一个变量的类型是在您第一次给它赋值的时候。

  • 强类型语言

    一种总是强制类型定义的语言。Java 和 Python 是强制类型定义的。您有一个整数，如果不明确地进行转换 ，不能将把它当成一个字符串去应用。

  • 弱类型语言

    一种类型可以被忽略的语言，与强类型相反。JS 是弱类型的。在JS中，可以将字符串 \'12\' 和整数 3 进行连接得到字符串\'123\'，然后可以把它看成整数 123 ，所有这些都不需要任何的显示转换。 所以说 Python 既是动态类型语言 (因为它不使用显示数据类型声明)，又是强类型语言 (因为只要一个变量获得了一个数据类型，它实际上就一直是这个类型了)。
JavaScript和ECMAScript的关系

基础数据类型

一、数值:number

  • NaN:属于Number类型的一个特殊值,当遇到将字符串转成数字无效时,就会得到一个NaN数据
  • NaN参与的所有的运算都是false,除了!=
  • var b = 5/0; console.log(b); Infinity 无限大
  • ps:在JavaScript中，只要是数，就是数值型(number)的。无论整浮、浮点数（即小数）、无论大小、无论正负，都是number类型的。
  • var age = Number(18);
  • parseInt("1.2"); parseFloat("1.2");
<script>
var a = 100;            //定义了一个变量a，并且赋值100
console.log(typeof a);  //输出a变量的类型
console.log(typeof(a));  //输出a变量的类型

var num = 2.379;
var newNum = num.toFixed(2);   //小数的保留  四舍五入
console.log(newNum);  //2.38

var numStr = num.toString();
console.log(typeof numStr);  //string   //将number类型转换成字符串类型
</script>
View Code

二、字符串:string

  • var a = "abcde"; var b = \'你好\'; //不区分单双引号
  • + 如果加号两边都是数值，此时是数字的加号。否则就是连字符（用来连接字符串）。
  • var name = String("hello");
  • 常用方法：     obj.trim()     obj.charAt(index)     obj.substring(start,end)     obj.indexOf(char)     obj.length
方法 说明
.length   #不加括号的是属性 返回长度
.trim()    #得到一个新值 移除空白
.trimLeft() 移除左边的空白
.trimRight() 移除右边的空白
.concat(value, ...) #s1=\'hello\';s.concat(\'xx\');得到helloxx 拼接
.charAt(n) #n类似索引，从0开始，超过最大值返回\'\'空字符串 返回第n个字符
[n] #n类似索引，可以使用方括号加数 字索引来访问字符串中的特定字符 返回第n个字符
.charCodeAt(n) #n类似索引，从0开始，超过最大值返回\'\'空字符串 返回第n个字符的字符编码 类似python中的ord()
String.fromCharCode(n) #n代表数字，String.fromCharCode(101) 返回第101代表的字符 类似python中的chr()
.indexOf(substring, start) #这个start是从索引几开始找，没有返回-1 子序列位置
.substr(start, length) #第一个参数指定字符串的开始位置,第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置。 基于子字符串创建新字符串的方法
.substring(from, to) #不支持负数，所以一般都不用它，了解一下就行了 根据索引获取子序列
.slice(start, end) #var s1=\'helloworld\';s1.slice(0,-5)看结果，就用它 切片
.toLowerCase() #全部变小写 小写
.toUpperCase()  #全部变大写 大写
.split(delimiter, limit)#分隔,s1.splite(\' \'),后面还可以加参数s1.split(\' \'，2),返回切割后的元素个数 分割

 
<script>
//创建方式
var str="hello world";
var str= new String("hello word");

//==================================================字符串位置方法
// chartAt(index) 返回指定索引的位置的字符
// charCodeAt()   String.fromCharCode
//[]

// indexOf  lastIndexOf  查询字符串位置  找不到则返回-1
//indexof()/search() 查找字符的下标，如果找到返回字符串的下标，找不到则返回-1 。

var str = \'hello world\';

console.log(str.charAt(1));//e
console.log(str.charCodeAt(1)); //输出"101"
console.log(str.String.fromCharCode(101)); //输出"e"
console.log(str[1]);   //"e"


console.log(str.indexOf(\'m\',0)); //-1
console.log(str.indexOf(\'o\',0)); //4
console.log(str.indexOf(\'o\',5)); //7

console.log(str.lastIndexOf(\'o\')); //7

console.log(str.search(\'m\')); //-1
console.log(str.search(\'o\')); //4



//match(regexp)         match返回匹配字符串的数组，如果没有匹配则返回null
var a = \'hello,world\';
var r = a.match("world");
console.log(r);   //["world", index: 6, input: "hello,world", groups: undefined]
var r = a.match("World");
console.log(r); //null

// 正则
var a = \'abcd,dcba\';
var r = a.match(/\\w+/);
console.log(r); //["abcd", index: 0, input: "abcd,dcba", groups: undefined]

// g表示匹配多次
var r = a.match(/\\w+/g);
console.log(r); //(2) ["abcd", "dcba"]


//==================================================子字符串处理方法
//slice(start，end) 左闭右开 切片操作字符串
//substr(start, length)  start表示开始位置，length表示截取长度
//substring(indexStart,indexEnd) 切子字符串。顾头不顾尾  indexEnd是结束位置

var stringValue = "hello world";
alert(stringValue.slice(3));//"lo world"
alert(stringValue.substring(3));//"lo world"
alert(stringValue.substr(3));//"lo world"

alert(stringValue.slice(3, 7));//"lo w"
alert(stringValue.substring(3,7));//"lo w"
alert(stringValue.substr(3, 7));//"lo worl"   //第二个参数指定的是要返回的字符个数。


alert(stringValue.slice(-3));//"rld"         //相当于调用了  slice(11-3)   即slice(8)
alert(stringValue.substring(-3));//"hello world"   //相当于调用了substring(0)
alert(stringValue.substr(-3)); //"rld"       //相当于调用了  substr(11-3)   即substr(8)
alert(stringValue.slice(3, -4));//"lo w"     //相当于调用了  slice(3,11-4)   即slice(3,7)
alert(stringValue.substring(3, -4));//"hel"  //相当于调用了  substring(3, 0)
// 如果 indexStart 大于 indexEnd 则 substring 的执行效果就像两个参数调换了一样   即 substring(0, 3)
alert(stringValue.substr(3, -4)); //""(空字符串)  //substr()会将第二个参数转换为 0   即substr(3,0) 返回包含零个字符的字符串，也就是一个空字符串。

/*
参数：
    为正值时：slice()，slice()，substring()第一个参数指定字符串的开始位置
            slice()和 substring()的第二个参数指定的是字符串最后一个字符后面的位置。
            substr()的第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置。

    为负值时：slice()方法会将传入的负值与字符串的长度相加，
            substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为 0
            substring()方法会把所有负值参数都转换为 0

            substring()两个参数相等，返回一个空字符串
                       没有参数时，返回整个字符串
                       如果第一个参数大于第二个参数，两个参数调换位置

*/

//==================================================字符串拼接方法
// concat 返回字符串值，表示两个或多个字符串的拼接一个新的字符串
var str1 = \'al\';
var str2  = \'ex\';
console.log(str1.concat(str2,str2));//alexex

//==================================================字符串替换方法
//replace(a,b) 将字符串a替换成字符串b
var a = \'1234567755\';
var newStr = a.replace("4567","****");
console.log(newStr);//123****755

//==================================================字符串分割方法
//split(\'a\',1) 以字符串a分割字符串，并返回新的数组。如果第二个参数没写，表示返回整个数组，如果定义了个数，则返回数组的最大长度
var str1="一,二,三,四,五,六,日";
var strArray=str1.split(",");
console.log(strArray[1]);//结果为"二"

var str =  \'我的天呢,a是嘛,你在说什么呢?a哈哈哈\';
console.log(str.split(\'a\'));//["我的天呢,", "是嘛,你在说什么呢?", "哈哈哈"]  如果第二个参数没写，表示返回整个数组
console.log(str.split(\'a\',2));//["我的天呢,", "是嘛,你在说什么呢?"] 如果定义了个数，则返回数组的最大长度

//==================================================字符串其他方法
/*
toLocaleLowerCase()和 toLocaleUpperCase()方法则是针对特定地区的实现。
对有些地 区来说，针对地区的方法与其通用方法得到的结果相同，但少数语言(如土耳其语)
会为 Unicode 大小 写转换应用特殊的规则，这时候就必须使用针对地区的方法来保证实现正确的转换.
*/
var str="    hello world   ";
//length 获取字符串的长度
//trim() 去除字符串两边的空格
console.log(str.length,str.trim().length);  //18 11
//toLowerCase()转小写
var str = \'HELLO\';
console.log(str.toLowerCase());//hello
//toUpperCase()转大写
var str = \'hello\';
console.log(str.toUpperCase());//HELLO
</script>
View Code

三、布尔：boolean

  • var status = true;
  • var status = false;
  • var status = Boolen(1==1)

四、空对象：null

  • var c1 = null;//空对象 console.log(c1,typeof c1) // null "object"
  • 如果函数或方法要返回的是对象，那么找不到该对象时，返回的通常是 null。
  • 值undefined 实际上是从值null 派生来的，因此 ECMAScript 把它们定义为相等的。
  • undefined 是声明了变量但未对其初始化时赋予该变量的值，null 则用于表示尚未存在的对象

五、未定义：undefined

  • var d1; console.log(typeof d1) //undefined 表示变量未定义
  • 当声明的变量未初始化时，该变量的默认值是 undefined。
  • 当函数无明确返回值时，返回的也是值 "undefined"
  • undefined 是声明了变量但未对其初始化时赋予该变量的值，null 则用于表示尚未存在的对象

数据类型转换

  • 将string类型转换成number类型:
    1. parseInt() ：字符串转数字
    2. parseFloat() : 字符串转小数
    3. Number()
  • 将number类型转换成string类型:
    1. 隐式转换: var n1 = 123;var n2 = \'123\';var n3 = n1+n2;console.log(typeof n3);
    2. 强制转换:String()和.toString：转字符串 var str1 = String(n1); 或 console.log(n1.toString())
  • Boolean()：任何数据类型都可以转成布尔值
将number类型转换成string类型
隐式转换:
var n1 = 123;var n2 = \'123\';var n3 = n1+n2;console.log(typeof n3);
强制转换:String()或toString()
var str1 = String(n1); 或 console.log(n1.toString())

将string类型转换成number类型
Number:
var stringNum = \'789.123wadjhkd\'; console.log(Number(stringNum)); //NaN
parseInt()或parseFloat
console.log(parseInt(stringNum)); //789
console.log(parseFloat(stringNum)); //789.123

任何的数据类型都可以转换为boolean类型
console.log(Boolean(0));
console.log(Boolean(\'\'));
console.log(Boolean(false));
console.log(Boolean(null));
console.log(Boolean(undefined));
console.log(Boolean(NaN));
console.log(Boolean(Infinity)); //true


<script>
//===================================parseInt() ：字符串转数字
var a = \'5\';
var a = parseInt(a);
console.log(typeof(a));

//带有自动净化的功能；只保留字符串最开头的数字，后面的中文自动消失。
console.log(parseInt("2018你好！！")); //2018

//自动带有截断小数的功能：取整，不四舍五入。
var a = parseInt(5.8) + parseInt(4.7);
console.log(a);  //9
var a = parseInt(5.8 + 4.7);
console.log(a); //10

//===================================parseFloat() : 字符串转小数
var a = parseFloat(\'5.8\')+ parseFloat(\'4.7\');
console.log(a); //10.5
var a = parseFloat(\'5.8\' + \'4.7\');
console.log(a); //5.84

//===================================Number
var stringNum = \'789.123wadjhkd\';
console.log(Number(stringNum)); //NaN

//===================================String()和.toString：转字符串 和 隐式转换
var n1 = 123;
var str1 = String(n1);
console.log(typeof str1); //string

var num = 234;
var str = num.toString();
console.log(num.toString(),typeof (num.toString()),str,typeof(str));

var n1 = 123;
var n2 = \'123\';
var n3 = n1+n2;
console.log(typeof n3, n3); //string 123123

//===================================Boolean()：任何数据类型都可以转成布尔值
var b1 = \'123\';  // true
var b3 = -123;  // true
var b4 = Infinity; //表示正无穷大 true

var b2 = 0;       // false
var b5 = NaN;     //false
var b6;              //表示undefined //false
var b7 = null;    //false

console.log(Boolean(0));// false
console.log(Boolean(\'\'));// false
console.log(Boolean(false));// false
console.log(Boolean(null));// false
console.log(Boolean(undefined));// false
console.log(Boolean(NaN));// false
console.log(Boolean(Infinity)); //true

</script>
View Code

内置对象类型

Javascript语言中的对象可以分为三种类型：

  • 用户定义对象（user-defined object）：由程序员自行创建的对象。
  • 内建对象（native object）:在JavaScript中除了null和undefined以外其他的数据类型都被定义成了对象，也可以用创建对象的方法定义变量，String、Math、Array、Date、RegExp都是JavaScript中重要的内置对象。
  • 宿主对象（host object）:由浏览器提供的对象，比如window对象
类型内置对象介绍
数据对象 Number 数字对象
String 字符串对象
Boolean 布尔值对象
组合对象 Array 数组对象
Math 数学对象
Date 日期对象
组合对象 Object 自定义对象
Error 错误对象
Function 函数对象
RegExp 正则表达式对象
Global 全局对象 
<script language="javascript">
var aa=Number.MAX_VALUE; 
//利用数字对象获取可表示最大数
var bb=new String("hello JavaScript"); 
//创建字符串对象
var cc=new Date();
//创建日期对象
var dd=new Array("星期一","星期二","星期三","星期四"); 
//数组对象
</script>
View Code

一、Array

方法 说明
.length 数组的大小
.push(ele) 尾部追加元素
.pop() 获取尾部的元素
.unshift(ele) 头部插入元素
.shift() 头部移除元素
.slice(start, end) 切片
.reverse() #在原数组上改的 反转
.join(seq)#a1.join(\'+\')，seq是连接符 将数组元素连接成字符串
.concat(val, ...) #连个数组合并,得到一个新数组，原数组不变 连接数组
.sort()   排序
.forEach() #讲了函数再说 将数组的每个元素传递给回调函数
.splice() #参数：1.从哪删(索引), 2.删几个  3.删除位置替换的新元素(可多个元素) 删除元素，并向数组添加新元素。
.map()  #讲了函数再说 返回一个数组元素调用函数处理后的值的新数组
.filter()  #讲了函数再说 它利用指定的函数确定是否在返回的数组中包含某一项

 
<script type="text/javascript">
//==================================================创建方式
//方式1、字面量方式(推荐)
var colo = [\'red\',\'green\',\'yellow\'];
//方式2、使用构造函数（后面会讲）的方式创建 使用new关键词对构造函数进行创建对象,构造函数与后面的面向对象有关系
var colors = new Array();
//方式3、
var test=new Array(100,"a",true);

//创建二维数组：
var cnweek=new Array(7);
for (var i=0;i<=6;i++){
    cnweek[i]=new Array(2);
}
cnweek[0][0]="星期日";
cnweek[0][1]="Sunday";
cnweek[1][0]="星期一";
cnweek[1][1]="Monday";
//...
cnweek[6][0]="星期六";
cnweek[6][1]="Saturday";
console.log(cnweek);

//==================================================数组的赋值
//通过下标进行赋值
var arr=[];
arr[0] = \'red\';
arr[1] = \'green\';
arr[2] = 123;


//==================================================数组的合并 concat()
var north = [\'北京\',\'山东\',\'天津\'];
var south = [\'东莞\',\'深圳\',\'上海\'];
var newCity = north.concat(south);
console.log(newCity,typeof newCity);  //["北京", "山东", "天津", "东莞", "深圳", "上海"] "object"


var a = [1,2,3];
var b=a.concat(4,5) ;
console.log(a);  //返回结果为1,2,3
console.log(b,typeof b);  //返回结果为1,2,3,4,5  object

//==================================================join()
// 将数组中元素使用指定的字符串连接起来，它会形成一个新的字符串
var score = [98,78,76,100,0];
var str = score.join(\'|\');
console.log(str,typeof str);//"98|78|76|100|0"  string
//==================================================数组的切片  slice(start, end)
// (左闭右开)  start表示开始位置索引  end是结束位置下一数组元素索引编号

/*
第一个数组元素索引为0
start、end可为负数，-1代表最后一个数组元素
end省略则相当于从start位置截取以后所有数组元素
*/
var arr1=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\',\'g\',\'h\'];
var arr2=arr1.slice(2,4);
var arr3=arr1.slice(4);
var arr4=arr1.slice(2,-1);

//==================================================toString方法：将数组转换成字符串
console.log(arr2.toString());//结果为"c,d"
console.log(arr3.toString());//结果为"e,f,g,h"
console.log(arr4.toString());//结果为"c,d,e,f,g"

var score = [98,78,76,100,0];
//toString() 直接转换为字符串  每个元素之间使用逗号隔开
var str = score.toString();
console.log(str);//98,78,76,100,0


//子数组操作  splice(start, deleteCount, value, ...)
/*
splice的主要用途是对数组指定位置进行删除和插入
start表示开始位置索引
deleteCount删除数组元素的个数
value表示在删除位置插入的数组元素
value参数可以省略
*/
var a = [1,2,3,4,5,6,7,8];
a.splice(1,2);
alert(a.toString());//a变为 [1,4,5,6,7,8]
a.splice(1,1);
alert(a.toString());//a变为[1,5,6,7,8]
a.splice(1,0,2,3);
alert(a.toString());//a变为[1,2,3,5,6,7,8]

//push pop这两个方法模拟的是一个栈操作，push压栈 pop弹栈
//==================================================pop 移除数组的最后一个元素
var arr = [\'张三\',\'李四\',\'王文\',\'赵六\'];
var bb = arr.pop(); //返回值就是删除的元素
console.log(arr,bb);//["张三", "李四", "王文"] "赵六"

//==================================================push() 向数组最后添加一个元素,并返回新的长度
var arr = [\'张三\',\'李四\',\'王文\',\'赵六\'];
var cc = arr.push(\'小马哥\'); //可以添加多个，以逗号隔开  返回最终数组长度
console.log(arr,cc);//["张三", "李四"，"王文"，"赵六"，"小马哥"] 5

//==================================================shift和unshift：
//unshift():向数组的开头添加一个或更多元素，并返回新的长度
//shift()：删除并返回数组的第一个元素
var arr1=[1,2,3];
var cc = arr1.unshift(4,5);
console.log(arr1,cc);  //结果为"4,5,1,2,3" 5
var dd=arr1.shift();
console.log(arr1,dd);  //结果为"5,1,2,3"  4

//==================================================reverse() 翻转数组
var names = [\'alex\',\'xiaoma\',\'tanhuang\',\'angle\'];
names.reverse();
console.log(names); //["angle", "tanhuang", "xiaoma", "alex"]

//==================================================sort对数组排序
var names = [\'alex\',\'xiaoma\',\'tanhuang\',\'abngel\'];
names.sort();
console.log(names); // ["alex", "angle", "tanhuang", "xiaoma"]
//数字的正确排序
/*
关于sort()需要注意：
      如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
      如果想按照其他标准进行排序，就需要提供比较函数，也就是自己提供一个函数提供排序规则，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
      若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
      若 a 等于 b，则返回 0。
      若 a 大于 b，则返回一个大于 0 的值。
*/
arr=[1,5,2,100];
arr.sort(intSort);
function intSort(a,b){
    return a-b;
}
console.log(arr); //1,2,5,100

//==================================================清空数组的几种方式
var array = [1,2,3,4,5,6];
array.splice(0);      //方式1：删除数组中所有项目
array.length = 0;     //方式1：length属性可以赋值，在其它语言中length是只读
array = [];           //方式3：推荐


//判断是否为数组：isArray()  布尔类型值 = Array.isArray(被检测的值)
var test = [1,\'a\',3];
console.log(Array.isArray(test));  //true


//js中数组的特性
//特性1: js中的数组可以装任意类型,没有任何限制.
//特性2: js中的数组,长度是随着下标变化的.用到多长就有多长.
var arr5 = [\'abc\',123,1.14,true,null,undefined,new String(\'1213\'),new Function(\'a\',\'b\',\'alert(a+b)\')];
alert(arr5.length);//8
arr5[10] = "hahaha";
alert(arr5.length); //11
alert(arr5[9]);// undefined

//==================================================forEach方法，设定每一个元素执行某函数
var arr = [\'alex\',\'wusir\'];
    arr.forEach(fn);
    function fn(item,index){
        console.log(index,item)
    }
/*
0 "alex"
1 "wusir"
*/

var numbers = [1,2,3,4,5,4,3,2,1];
numbers.forEach(function(item, index, array){
    console.log(index,item,array)
});

//==================================================map方法，循环每一个元素完成某操作返回新的值组成新数组
var arr = [\'alex\',\'wusir\'];
    var ret = arr.map(fn);
    function fn(item,index) {
        console.log(index,item);
        return item+\'sb\'
    }
    console.log(ret);
/*
0 "alex"
1 "wusir"
["alexsb", "wusirsb"]
*/

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.map(function(item, index, array){
    return item * 2;
});
alert(filterResult); //[2,4,6,8,10,8,6,4,2]

//==================================================filter 它利用指定的函数确定是否在返回的数组中包含某一项。
// 例如要返回一个所有数值都大于2的数组，可以使用如下代码。
var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item, index, array){
    return (item > 2);
});
alert(filterResult); //[3,4,5,4,3]


//==================================================toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。

var colors = [\'red\',\'green\',\'blue\'];
alert(colors.toString());//red,green,blue


var person1 = {
    toLocaleString : function () {
        return \'马大帅\';
    },
    toString : function () {
        return \'马小帅\';
    }
};
var person2 = {
    toLocaleString : function () {
        return \'张大帅\';
    },
    toString : function () {
        return \'张小帅\';
    }
};
var people = [person1,person2];
alert(people);//马小帅,张小帅
alert(people.toString());//马小帅,张小帅
alert(people.toLocaleString()); //马大帅,张大帅
</script>
View Code

二、Math

方法 说明
Math.floor() 向下取整，称为“地板函数”
Math.ceil() 向上取整，称为“天花板函数”
Math.max(a,b) 求a和b中的最大值
Math.min(a,b) 求a和b中的最小值
Math.random() 随机数，默认0-1之间的随机数，公式min+Math.random()*(max-min),求min-max之间的数
Math.E 自然对数的底数，即常量e的值
Math.LN10 10的自然对数 ln(10)
Math.LN2 2的自然对数
Math.LOG2E 以2为底e的对数
Math.LOG10E 以10为底e的对数
Math.PI π的值
Math.SQRT1_2 1/2的平方根(即2的平方根的倒数)
Math.SQRT2 2的平方根 
<script type="text/javascript">

//该对象中的属性方法 和数学有关.
/*
abs(x)    返回数的绝对值。
exp(x)    返回 e 的指数。
floor(x)对数进行下舍入。
log(x)    返回数的自然对数（底为e）。
max(x,y)    返回 x 和 y 中的最高值。
min(x,y)    返回 x 和 y 中的最低值。
pow(x,y)    返回 x 的 y 次幂。
random()    返回 0 ~ 1 之间的随机数。
round(x)    把数四舍五入为最接近的整数。
sin(x)    返回数的正弦。
sqrt(x)    返回数的平方根。
tan(x)    返回角的正切。
*/

console.log(Math.pow(2,4));// 16  pow 计算参数1 的参数2 次方.
console.log(Math.round(1.5)); // 2  四舍五入

// Math.ceil() 向上取整，\'天花板函数\'
var x = 1.234;
以上是关于Linux运维之路的主要内容，如果未能解决你的问题，请参考以下文章
 

 linux运维之路


 linux运维之路


 Linux运维之路


 Linux运维进阶之路


 Linux运维之路  基础篇：Linux基础命令


 Linux运维之路