4-引用类型

[Ogurimuio]

引用类型

又被称为“对象定义”，引用类型的值——是引用类型的一个实例。

比如创建object时，即创建了引用类型的一个新实例。

Object类型

创建object类型的方法

1. var person=new Object();
   person.name="nichal"

2. var person={
   	"name":"nichal",	//有逗号
   	"age":29		//这里最好不加逗号
   }

3. var person={}
   person.name="nichal"
   person.age=29

可以通过使用 typeof 来检测对象中是否含有某个特定的属性。

alert(typeof person.age=="number")	//返回true或false

除了点表示法外，还可以使用方括号表示法

alert(person["name"])
alert(person["first name"])	//属性名中包含空格，不能用点表示法，可以使用方括号法

方括号法——可以通过变量来访问属性↓

var newName="name"
alert(person[newName])	//可输出属性“name”的值

Array类型

array类型：可以在同一个数组中保存不同的数据类型。

创建方法

var color=new Array()
var color=new Arrat(3)	//数组长度为3
var color=new Arrat("Grey","red")

//数组字面量表示法
var color=["Grey","red"]；
var color=[]	//空数组

//不要做以下这样
var color=[1,2,]	//2项或3项，不明确
var color=[,,,] 	//3项或4项，不明确

length属性

var color=["Grey","red"]；	//length=2
color.length=1;		//自动去除长度为1之后的所有内容
color.length=3;		//自动添加长度，添加的部分内容为undefined
color[color.length]="black"	//在数组末尾添加一个颜色

检测数组

• instanceof

value instanceof Array

需要在单一的全局执行环境中。

若有两个以上不同的全局执行环境，则会有两个以上不同版本的Array构造函数

• Array.isArray()

Array.isArray(value)

数组转换

数组转换成字符串

• toString()，toLocalString()，valueOf()

var color=["Grey","red"]；
alert(color.toString())		//"Grey,red"
alert(color.toLocalString())		//"Grey,red"
alert(color.valueOf())		//"Grey,red"
alert(color)				//"Grey,red"

默认都返回以逗号分隔的字符串形式。

• join()

可以使用不同的分隔符来构建字符串

var color=["Grey","red"]；
alert(color.join("|"))		//"Grey|red"

栈方法

将数组看作是一个栈，有push和pop方法，后进先出

var item=color.push("black")	//返回数组长度
var item=color.pop()

队列方法

先进先出，有push和shift方法，此外还有unshift方法

var item=color.push("black")	//返回数组长度
var item=color.shift()		//获取第一项
var item=color.unshift("black")	 //在前端添加，并返回数组长度

重排序方法

• reverse()：会反转数组项的顺序，即倒排。

• sort()：默认是按升序排序数组项。运用toString方法转为字符串，再进行比较。数字也是转为字符串比较,并不是按数字大小比较。

  var value=[0,1,5,10,15]
  value.sort()
  alert(value)	//0,1,10,15,5

  **compare（）**方法：比较两个参数，若为升序，则前者大返回1.若为降序则相反即可。可适用于大多数数据类型。

  function compare(v1,v2){
      if(v1<v2)	return -1;		//升序，排列正确,v1小
      if(v1>v2)	return 1;		//升序，排列错误，v1大
      else return 0;
  }
  var value=[0,1,5,10,15]
  value.sort(compare)
  alert(value)	//0,1,5,10,15 结果按升序排序
   

  如果按照升序排序，则compare可以简化成：

  function compare(v1,v2){
      return v2-v1;
  }

操作方法

• concat()：基于当前数组中的所有项，创建一个新数组。

  var color=["red"]
  var color2=color.concat("yellow",["black","brown"])
  
  //color:red
  //color2:red,yellow,black,brown

• slice()：基于当前数组中的一个或多个项创建一个新数组。

  ​ 接收两个参数：则是指定起始位置和结束位置

  ​ 接收一个参数：则是指定起始位置到数组结束。

• splice()：向数组的中部插入项。

  • 删除：两个参数，要删除的第一项位置，要删除的项数。返回的是删除的内容。

  • 插入：三个参数，起始位置，0（本来是要删除的项数），要插入的项。返回的是空数组

  • 替换：三个参数，起始位置，要插入的任意数量的项。

    splice(2,1,"red","green") 会删除第二项，并在位置2开始插入字符串。返回的是删除的内容。

位置方法

查找数组中指定内容的位置，若没有则返回-1。

• indexOf()：从前往后找
• lastIndexOf()：从后往前找

都是接受两个参数：查找的项、查找起点位置（可空）

比较时，使用的是全等，===。因此需要严格相等才算相等。

迭代方法

迭代函数的方法有以下几个：

都是对数组中的每一项运行给定函数

• every（）：若每一项都返回true，则返回true。
• some（）：若任意一项都返回true，则返回true。
• filter（）：返回true的项组成的数组。
• map（）：返回每次函数调用结果组成的数组。
• forEach（）：没有返回值。

这些方法都是接收两个参数：

1. 在每项上运行的函数：函数要有三个参数：数组项的值item、该项的位置index、数组本身Array
2. 运行该函数的作用域对象：可空，影响this的值

var num=[1,2,3,4,5,6]

var everyResult=num.every(function(item,index,array){
	return (item>2)	//函数内容为：判断是否大于2
})
alert(everyResult)	//false


var filterResult=num.filter(function(item,index,array){
	return (item>2)	//函数内容为：判断是否大于2
})
alert(filterResult)	//[3,4,5,6]


var mapResult=num.map(function(item,index,array){
	return item*2	//函数内容为：判断是否大于2
})
alert(mapResult)	//[2,4,6,8,10,12]

缩小方法

两个方法迭代数组的所有项，然后构建一个最终返回的值。

• reduce（）：从前往后迭代
• reduceRight（）：从后往前迭代

两个方法，都是接收两个参数：

1. 在每项上调用的函数：函数有4个参数：前一个值，当前值，项的索引和数组对象
2. 作为缩小基础的初始值（可空）

var value=[1,2,3,4,5]
var sum=value.reduce(function(prev,cur,index,array){
	return prev+cur
})
alert(sum);

Date类型

创建：（默认存储当前时间）

var now=new Date()

根据特定的日期时间创建，需要传入毫秒数（从1970年1月1日午夜起到该日期经过的毫秒数）

• parse（）方法：

  var someDate=new Date(Date.parse("May 25,2004"))
  var someDate=new Date("May 25,2004")

• UTC（）方法：

  //表示2005年5月5日下午5:55：55
  var someData=new Data(Date.UTC(2005,4,5,17,55,55))

  注意：月份0表示1月。

  且参数只有年月是必须的，若其他参数没有提供，则默认为0（天数默认为1）。

获取当前时间的函数：

var now=Date.now();

Date的toLocaleString（）和toString（）方法在不同浏览器中不同。toString有包含时区。

Date返回的不是字符串，而是毫秒，因此可以直接比较

var date1=new Date(2007,0,1)	//2007年1月1日
var date2=new Date(2007,1,1)	//2007年2月1日
alert(date1<date2) //true

日期格式化

将日期格式化为字符串的方法

• toDateString（）：以特定于实现的格式显示星期几、月、日和年
• toTimeString（）：以特定 于实现的格式显示时、分、秒和时区
• toLocaleDatestring（）：以特定于地区的格式显示星期几、月、日和年
• toLocaleTimeString （）：以特定于实现的格式显示时、 分、秒
• toUTCString（）：以特定 于实现的格式完整的UTC日期。

与tolocaleString ()和toString()方法一样，以上这些字符串格式方法的输出也是因浏览器而异的。

RegExp类型

通过RegExp类型来支持正则表达式

var expression=/pattern/flags;

flags：

• g：表示全局global，应用于所有字符串，而不是找到第一个匹配的就停止。
• i：表示不区分大小写
• m：表示多行multiline模式，即在到达一行文本末尾时，还会继续查找下一行中是否存在匹配的项。

//使用正则表达式字面量
//不区分大小写查找第一个“bat”或者“cat”
var pattern1=/[bc]at/i;
//不区分大小写查找所有以“at”结尾的3个字符的组合
var pattern2=/.at/gi;

//不区分大小写查找第一个“[bc]at”,需要转义\
var pattern3=/\[bc\]at/i;


//使用构造函数创建
var pattern4=new RegExp("[bc]at","i")	//与pattern1一样
//使用构造函数转义时，需要使用双重转义
var pattern5=new RegExp("\\[bc\\]at","i") //与pattern3一样

字符\ ，添加转义后是\\，双重转义是\\\\

使用正则表达式字面量和使用构造函数创建正则表达式的不同：

for(i=0;i<10;i++)
{
    re=/cat/g;
    re.test("catastrophe");
}//第二次调用时，是从位置为3的字符开始的，而不是从头，所以只有第一次返回true。

for(i=0;i<10;i++)
{
    re=new RegExp("cat","g");
    re.test("catastrophe");
}//每次都是新建一个RegExp实例，所有每次都是返回true

RegExp实例方法

• exec（）：为捕获组而设计

  var text = "mom anđ đađ anđ baby" ; .
  
  var pattern = /mom( anđ dad( and baby)?)?/gi;
  //包含两个捕获组，“and baby”和包含它的“anđ dad and baby”
  
  var matches = pattern. exec (text) ;
  alert (matches.index) ;  // O 整个字符串符合，所以返回0
  
  alert (matches.input) ;  // "mom anđ dad anđ baby"
  alert (matches[0]) ;
  // "mom anđ dad and baby' 匹配的整个字符串
  alert (matches[1]) ; 
  // " and dad and baby' 与第一个捕获组匹配的内容
  alert lmatches[2]) ;  
  //"and baby" 与第二个捕获组匹配的内容

  对于exec来说，即使设置了全局标志g，它每次也只会返回一个匹配项，但也有所不同：

  • 若不设置全局标志，则多次调用也将始终返回第一个匹配项内容

  • 若设置全局标志，则多次调用会沿上一次查找到的位置继续查找新的匹配项。

• test（）：匹配返回true，只想知道是否匹配而不需要知道内容的情况下使用。常用在if语句中。

  var text="000-00-0000"
  var pattern=/\d{3}-\d{2}-\d{4}/;
  
  //w表示文字，d表示数字，记得加转义符。
  
  if(pattern.test(text)){
      alert("ok")
  }

RegExp构造函数属性

有以下属性

var text = "this has been a short summer" ;
var pattern = /(.)hort/g;

/*
*注意: Opera不支持 input. lastMatch, lastParen fo 		     multiline 属性
*Internet Explorer 不支持 multiline属性
 */

if (pattern.test (text)){
      alert(RegExp.input)  
    // this has been a short summer .
      alert(RegExp.1eftContext) 
    // this has been a
      alert(RegExp.rightcontext) //summer
      alert(RegExp.lastMatch)	//short
      alert(RegExp.lastParen)	//s
      alert(RegExp.multiline) //false

}

除此之外，还有RegExp.$1 用于存储第一个匹配的捕获组。

var text = "this has been a short summer" ;
var pattern = /(.)ho(..)/g;

if (pattern.test(text)){
      alert(RegExp.$1)	//s
      alert(RegExp.$2) //rt

}

Function类型

函数实际上的对象，是Function的实例。具有属性和方法。

函数的创建

function sum(num1,num2)
{
    return num1+num2
}
//或者
var sum=function(num1,num2)
{
    return num1+num2
};
//第二种方法：没有函数名（函数名可有可无），可以直接通过变量sum引用。
//第二种方法：函数末尾有个分号，就像声明变量一样

//不推荐的第三种方法:使用Function构造函数（和创建实例一样）
var sum=new Function("num1","num2","return num1+num2");
//需要解析两次代码

“函数是对象，函数名是指针”，因此一个函数可能有多个名字（多个变量指向函数本身）

function sum(num1,num2)
{
    return num1+num2
}
alert(sum(10,10))	//20

var anotherSum=sum		//新建一个变量和sum指向同一个函数
alert(anothersum(10,10))	//20

sum=null		//sum与函数“断绝关系”后，anothersum依然可用
alert(anothersum(10,10))	//20

不带（）的函数引用，是访问函数指针，即函数本身。

带（）的函数引用，是访问函数的返回值

函数没有重载

若创建第二个同名函数，则会覆盖前一个函数。因为 函数名是指针

函数声明与函数表达式

函数声明与函数表达式，在解析器向执行环境中加载数据时，有区别。

• 函数声明：

alert(sum(10,10))	//可以正确运行

function sum(num1,num2)
{
    return num1+num2
}

此时函数位于函数声明中。在代码开始前，解析器会通过函数声明提升的过程，加载函数声明。js引擎会把函数声明提升到顶部，因此上面的代码可以正确运行

• 函数表达式：

alert(sum(10,10))	//产生错误

var sum=function(num1,num2)
{
    return num1+num2
};

此时函数位于一个初始化语句中，而不是函数声明中。执行第一行代码时，sum没有声明。

作为值的函数

• 函数可以作为返回值
• 函数可以作为传入的参数

function func1(a,b)
{
    return a(b);
}
function func2(num)
{
    return num+10;
}
var result=func1(func2,10)	//注意func2后面没有括号，是访问函数指针
alert(result)	//20

• 函数中可以嵌套函数，在返回值中定义一个新的函数

  //对某个属性进行sort排序
  var data=[{
      name:"Zacha",
      age:20
  },{
      name:"Cacha",
      age:25
  }]
  
  function compareFunction(property)
  {
      return function(obj1,obj2)
      {
          var v1=obj1[property]
          var v2=obj2[property]
          
          if(v1<v2) return -1;
          else if(v1>v2) return 1;
          else return 0
      }
  }
  
  data.sort(compareFunction("name"))	//以属性name为排列标准，标准定义在compareFunction函数中
  
  /*此时data为[{
      name:"Cacha",
      age:25
  },{
      name:"Zacha",
      age:20
  }]
  */

函数内部属性

函数内部有两个特殊的对象

1. arguments：类数组对象，用于保存函数参数。但它有一个名为callee的属性，改属性是一个指针，指向拥有这个arguments对象的函数

   //递归时
   function factorial(num)
   {
   	if(num=1) return 1;
       else 
           return num*factorical(num-1)
       //这种方法正确，但会把函数的执行与函数名factorial耦合在一起
   }
   
    //可以使用callee属性消除这种耦合
   function factorial(num)
   {
   	if(num=1) return 1;
       else 
           return num*arguments.callee(num-1)
   }

2. this：this引用的是函数以执行的环境对象，即this值。

   （在网页中调用函数时，this引用的是window）

   window.color="red"
   var o={color:"blue"}
   
   function sayColor()
   {
       alert(this.color)
   }
   sayColor();		//red,此时是window
   
   o.sayColor=sayColor;	//两个函数指向相同的函数
   o.sayColor()	//blue，此时是o

3. 还有一个函数对象的属性：caller，保存着调用当前函数的函数。

   若在全局中调用，则为null。

   function outer(){
       inner();	//outer调用了inner函数
   }
   function inner(){
       alert(inner.caller);	//指向调用当前函数的函数，即outer
       //或者使用松耦合
       alert(arguments.callee.caller)
   }
   
   outer(); 

   在严格模式下，访问arguments.callee会错误，定义的arguments.caller也会错误，在非严格模式下，arguments.caller始终的undefined。

函数属性和方法

函数的属性：

1. length：表示函数希望接收的命名参数的个数。
2. prototype：保存所有实例方法的真正所在。如：toString（），valueOf（）都是保存在这里面。对于创建自定义引用类型以及实现继承时很重要。

函数的方法（非继承）：

都是在特定的作用域中调用函数，即设置this对象的值

1. apply（）：两个参数：运行函数的作用域this、参数数组（可以是Array或arguments）。

   function sum(num1,num2){
       return num1+num2
   }
   function call1(num1,num2){
       return sum.apply(this,arguments)	//传call1的arguments
   }
   function call2(num1,num2){
       return sum.apply(this,[num1,num2])	//传array
   }
   
   alert(call1(10,10))	//20
   alert(call2(10,10))	//20

2. call（）：和apply作用一样，但是传参时，除了this之外，其他参数要一个一个传

   function sum(num1,num2){
       return num1+num2
   }
   function call(num1,num2){
       return sum.apply(this,num1,num2)	
   }
   
   alert(call(10,10))	//20

这两个方法更重要的作用是能够扩大函数的作用域，且对象与方法不需要耦合。

window.color="red"
var o={color:"blue"}

function sayColor()
{
    alert(this.color)
}
sayColor();		//red,此时是window

o.sayColor=sayColor;	//两个函数指向相同的函数
o.sayColor()	//blue，此时是o
//对象和方法耦合

//有了call之后
sayColor.call(this);	//red
sayColor.call(window);	//red
sayColor.call(o);	//blue

//还定义了一个bind方法，this值会直接绑定为bind的参数
var newSayColor=sayColor.bind(o)
newSayColor(); 		//blue

基本包装类型

String、Number、Boolean。

var s1="some text"		//s1是基本类型值，不是对象
s1.color="red"
//这句话之后，后台完成了
/* var s1=new String（"some text"） 创建一个String对象
*	s1.color="red"	
*	s1=null		销毁
*/
alert(s1.color) //undefined
//此时第二句话创建的s1对象已经销毁。这句话时又重新创建了一个s1对象，此时color属性是undefined

使用new Object 会调用Object构造函数，通过传入参数的类型，包装成相应的基本类型的实例

也可以显式的使用new String/Number/Boolean，创建object类型的实例。尽量不使用。

var obj = new Object("text")	//类型为”String“的实例，即对象，使用typeof会返回”object“
alert（obj instanceof String） //true

//有new和没有new不一样
var value=”25“		//string基本类型值
var number=Number(value)	//转型函数
alert(typeof number)	//number

var obj=new Number(value)	//构造函数
alert(typeof obj)	//object

Boolean

在Boolean的所有对象都会被转换成true，建议不要使用Boolean对象。

Number

• toFixed（）方法，会按照指定小数位返回数值的字符串

var num=10		
alert(num.toFixed(2))	//"10.00"
//第二句时，后台会自动执行基本类型值转Object

• toExponential（），返回以指数表示法的字符串，参数为小数点位数

var num=10		
alert(num. toExponential(1))	//"1.0e+1"

• toPrecision（），返回固定大小格式或指数格式。参数为数值的所有数字位数

  var num=99		
  alert(num. toPrecision(1))	//"1e+2" 100
  alert(num. toPrecision(2))	//"99"
  alert(num. toPrecision(3))	//"99.0"

String

属性：length，包含的字符串长度，包含空格

方法：

• 字符方法：访问字符串中特定字符

  1. charAt（）：参数是字符的位置（从0开始）
  2. charCodeAt（）：参数是字符的位置（从0开始），但返回的是字符编码，例如：如果是“e”，返回的是“101”
  3. 有些浏览器支持，直接使用方括号加数字来访问。如StringValue[1]

• 字符串操作方法

  1. concat（）：将一个或多个字符串拼接起来，返回新字符串

     var str1="hello"
     var result=str1.concat("world","!") 
     //可接收多个多个参数

  2. 直接使用+号，对字符串进行拼接。

  3. slice（）、substr（）、substring（）：基于子字符串创建新字符串。

     var str1="hello world"
     
     alert(str1.slice(3));		//"lo world"
     alert(str1.substring(3));	//"lo world"
     alert(str1.substr(3));		//"lo world"
     
     alert(str1.slice(3,7));		//"lo w"
     alert(str1.substring(3,7));	//"lo w"
     alert(str1.substr(3,7));	//"lo worl"

     第一个参数都代表开始的位置。

     slice（）、substring（）的第二个参数是结束的位置，结束位置的字符也不留下。

     substr（）的第二个参数是值留下字符的长度。

     当参数有负数时：

     var str1="hello world"
     
     alert(str1.slice(-3));		//"rld"  11+(-3)=8
     alert(str1.substring(-3));	//"hello world" -3变0
     alert(str1.substr(-3));		//"rld" 11+(-3)=8
     
     alert(str1.slice(3,-4));	//"lo w" 11+(-4)=7
     alert(str1.substring(3,-4));	//"hel" -4变0，两个参数数值大的在前面
     alert(str1.substr(3,-4));	//""  空字符串

• 字符串位置方法

  在字符串中搜索给定的子字符串，返回位置。若不存在则返回-1

  第一个参数：搜索的字符串

  第二个参数（可选）：开始搜索的位置

  1. indexof（）：从头开始
  2. lastIndexOf（）：从尾开始

  可以与循环搭配使用，找出所有匹配的子字符串

• 大小写转换方法

  1. 大写换成小写：toLocaleLowerCase（）、toLowerCase（）

  2. 小写换成大写：toLocaleUpperCase（）、toUpperCase（）

• 模式匹配方法

  1. match（）：与RegExp的exec（）方法相同，只接受一个参数：正则表达式或者RegExp对象，返回匹配的内容数组

     var text="cat,bat"
     var pattern=/.at/
     
     var matches=text.match(pattern)	//返回的是数组
     //等于 var matches=pattern.exec(text)
     alert(matches.index)	//0
     alert(matches[0])	//"cat"

  2. search（）：只接受一个参数：正则表达式或者RegExp对象，返回字符串中第一个匹配项的索引**（位置）**

  3. replace（）：两个参数：

     1. 第一个参数：RegExp对象 或 一个字符串
     2. 第二个参数：一个字符串 或 一个函数

     var text="cat,bat,sat"
     
     var result=text.replace("at","ond")
     //只会把第一个at改为ond，"cond,bat,sat"
     
     var result=text.replace(/at/g,"ond")
     //会把所有at改为ond，"cond,bond,sond"
     
     var result=text.replace(/（.at）/g,"word（$1）")
     //"word(cat),word(bat),word(sat)" 
     //将所有.at变为，word（第一个捕获组匹配的内容），.at为第一个捕获组
     
     var text2="<p class=\"greeting\">Hello world</p>"
     var result=text2.replace(/[<>"&]/g,function(match,pos,originalText) {
         switch(match){
             case "<":return "&lt";
             case ">":return "&gt";
             case "&":return "&amp";
             case "\":return "&quot";
         }
     })
     //会把所有<变为&lt……

  4. split（）：基于指定的分隔符，将字符串分隔为多个字符串，放入数组中。两个参数：

     1. 分隔符：字符串 或 RegExp对象
     2. 指定数组的大小（可选）

     var text="cat,bat,sat"
     var color1=color.split(",",2)	//["cat","bat"]
     var color2=color.split(/[^\,]+/) //匹配逗号
     //["",",",",",""] 空，逗号，逗号，空

• 字符串比较方法：localeCompare（）

  返回值：

  1. 字符串应排在字符串参数前：负数-1
  2. 字符串应排在字符串参数后：正数1
  3. 字符串=字符串参数：0

  var str="yellow"
  str.localeCompare("brick")	//1,yellow在后面

• 构造函数的静态方法：fromCharCode（）

  接收字符编码，转换成一个字符串。与charCodeAt（）相反。

  参数是每个字母的字符编码。

• HTML方法

  js动态格式化HTML

  尽量不使用这些方法，因为创建的标记通常无法表达语义。

  （表格见5.6最后一个方法）

单体内置对象

内置对象：不依赖宿主环境的对象，这些对象在ECMAScript程序执行前就已经存在。

也就是说，开发者不必显式地实例化内置对象，因为他们已经实例化了。

内置对象的例子：Object、Array和String

还有两个单体内置对象：Global、Math。

• Global对象：即全局对象，这个对象是不存在的，所有在全局作用域中定义的属性和函数，都是Global对象的属性和方法。是一种“兜底对象”。

  它还包含其他的一些方法：

  1. URI编码方法：encodeURI（）、encodeURIComponent（）方法。

     可以对URI（通用资源标识符）进行编码，以便发给浏览器。

     它可以替换所有无效的字符（比如空格），替换成%，从而让浏览器能够接受。

     • encodeURI（）：全局，不会对自身的特殊字符编码，如：冒号、正斜杠、问号、井号

     • encodeURIComponent（）：对某一段，会替换所有非字母数字字符

     互相对应：decodeURI（）、decodeURIComponent（）解码

  2. eval（）方法：一个完整的解析器，只接受一个参数：要执行的字符串（可以是任何js语句、函数、）。

     在eval中创建的变量和函数，都不会被提升，只在eval（）执行的时候才创建。

  属性：

  ​ 特殊值（undefined、Infinity）、所有原生引用类型的构造函数（Object、Function）

  通常是将Global对象作为window对象的一部分加以实现的。

• Math对象：保存数学公式和信息的位置。

  方法：

  1. min（）、max（）：接收多个参数，返回参数中最大/最小值。

     要是想传数组，可以使用apply（）

     var values=[1,2,3,4,5]
     var max=Math.max.apply(Math.values)
     

  2. 舍入方法：接收一个参数

     • Math.ceil():向上舍入
     • Math.floor():向下舍入
     • Math.round():四舍五入

  3. 随机数：random（），返回一个介于0-1之间的随机数，不包括0,1.

     var v=Math.floor(Math.random()*可能值的总数+最小的可能值)