JavaScript 字符串

字符串（或文本字符串）是一串字符（比如 "Bill Gates"）。
字符串被引号包围。您可使用单引号或双引号
您可以在字符串内使用引号，只要这些引号与包围字符串的引号不同
var answer = "He is called 'Bill'"; // 双引号内的单引号
var answer = 'He is called "Bill"'; // 单引号内的双引号

slice()方法返回一个索引和另一个索引之间的字符串，语法如下：
str.slice(beginIndex[, endIndex])
下面有三点需要注意：
若beginIndex为负数,则将该值加上字符串长度后再进行计算（如果加上字符串的长度后还是负数，则从0开始截取）。
如果beginIndex大于或等于字符串的长度，则slice()返回一个空字符串。
如果endIndex省略，则将slice()字符提取到字符串的末尾。
如果为负，它被视为strLength + endIndex其中strLength是字符串的长度。

substr()方法返回从指定位置开始的字符串中指定字符数的字符，语法如下：
str.substr(start, [length])
下面有四点需要注意：
substr()会从start获取长度为length字符（如果截取到字符串的末尾，则会停止截取）。
如果start是正的并且大于或等于字符串的长度，则substr()返回一个空字符串。
若start为负数,则将该值加上字符串长度后再进行计算（如果加上字符串的长度后还是负数，则从0开始截取）。
如果length为0或为负数，substr()返回一个空字符串。
如果length省略，则将substr()字符提取到字符串的末尾。

substring()方法返回一个索引和另一个索引之间的字符串，语法如下：
str.substring(indexStart, [indexEnd])
下面有六点需要注意：
substring()从提取的字符indexStart可达但不包括 indexEnd
如果indexStart 等于indexEnd，substring()返回一个空字符串。
如果indexEnd省略，则将substring()字符提取到字符串的末尾。
如果任一参数小于0或是NaN，它被视为为0。
如果任何一个参数都大于stringName.length，则被视为是stringName.length。
如果indexStart大于indexEnd，那么效果substring()就好像这两个论点被交换了一样；
例如，str.substring(1, 0) == str.substring(0, 1)

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); //输出 "lo world"
alert(oStringObject.substr("3")); //输出 "lo world"
alert(oStringObject.substring("3")); //输出 "lo world"
alert(oStringObject.slice("3", "7")); //输出 "lo w"
alert(oStringObject.substr("3", "7")); //输出 "lo worl"
alert(oStringObject.substring("3", "7")); //输出 "lo w"
alert(oStringObject.slice("-3")); //输出 "rld"
alert(oStringObject.substr("-3")); //输出 "rld"
alert(oStringObject.substring("-3")); //输出 "hello world"
alert(oStringObject.slice("3", "-4")); //输出 "lo w"
alert(oStringObject.substr("3", "-4")); //输出 ""
alert(oStringObject.substring("3", "-4")); //输出 "hel"

removeRepetition(str)去掉字符串str中，连续重复的地方
console.log(removeRepetition("aaa")); // ->a
console.log(removeRepetition("abbba")); // ->aba
console.log(removeRepetition("aabbaabb")); // ->abab
console.log(removeRepetition("")); // ->
console.log(removeRepetition("abc")); // ->abc

diyTrim(str)实现一个字符串头尾去除空格的函数，包括全角、半角空格
console.log(diyTrim(' a f b ')); // ->a f b
console.log(diyTrim(' ffdaf ')); // ->ffdaf
console.log(diyTrim('1 ')); // ->1
console.log(diyTrim('　　f')); // ->f
console.log(diyTrim(' 　 a f b 　　 ')); // ->a f b
console.log(diyTrim(' ')); // ->
console.log(diyTrim('　')); // ->
console.log(diyTrim('')); // ->

ECMAScript字符串对象方法

charAt() 和 charCodeAt() 方法
两个方法 charAt() 和 charCodeAt() 访问的是字符串中的单个字符。
这两个方法都有一个参数，即要操作的字符的位置。
charAt() 方法返回的是包含指定位置处的字符的字符串：
var oStringObject = new String("hello world");
alert(oStringObject.charAt(1)); //输出 "e"
alert(oStringObject.charCodeAt(1)); //输出 "101"

concat() 方法
字符串连接起来，相当于+号
var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult); //输出 "hello world"
alert(oStringObject); //输出 "hello "

indexOf() 和 lastIndexOf() 方法
方法返回的都是指定的子串在另一个字符串中的位置，如果没有找不到子串，则返回 -1
var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o")); 输出 "4"
alert(oStringObject.lastIndexOf("o")); 输出 "7"

localeCompare() 方法
注释：如果返回负数，那么最常见的是 -1，不过真正返回的是由实现决定的。
如果返回正数，那么同样的，最常见的是 1，不过真正返回的是由实现决定的。
var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick")); //输出 "1"
alert(oStringObject.localeCompare("yellow")); //输出 "0"
alert(oStringObject.localeCompare("zoo")); //输出 "-1"

toLowerCase()和toUpperCase()字符串并将所有字符分别转换为小写或大写。
例如，如果要在将数据存储在数据库中之前对所有用户输入的数据进行规范化，这可能非常有用。

JavaScript 数值

JavaScript 只有一种数值类型。
写数值时用不用小数点均可
var x1 = 34.00; // 带小数点
var x2 = 34; // 不带小数点
超大或超小的数值可以用科学计数法来写
var y = 123e5; // 12300000
var z = 123e-5; // 0.00123
所有 JavaScript 数字均为 64 位
如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，
如果前缀为 0 和 "x"，则解释为十六进制数。
var y=0377;
var z=0xFF;
y //255
z //255

ECMAScript数值对象方法

toFixed() 方法
toFixed() 方法返回的是具有指定位数小数的数字的字符串表示，四舍五入。
var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2)); //输出 "68.00"
空的字符串位由 0 来补充。对于处理货币的应用程序，该方法非常有用。
toFixed() 方法能表示具有 0 到 20 位小数的数字，超过这个范围的值会引发错误。

toExponential() 方法
返回的是用科学计数法表示的数字的字符串形式，四舍五入。
var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1)); //输出 "6.8e+1"

toPrecision() 方法
toPrecision() 方法根据最有意义的形式来返回数字的预定形式或指数形式，四舍五入。
它有一个参数，即用于表示数的数字总数（不包括指数）
var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1)); //输出 "7e+1"
alert(oNumberObject.toPrecision(2)); //输出 "68"
alert(oNumberObject.toPrecision(3)); //输出 "68.0"

JavaScript 布尔值

布尔值只有两个值：true 或 false。

下面6种值转化为布尔值时为false，其他转化都为true

1、undefined（未定义，找不到值时出现）

2、null（代表空值）

3、false

4、0

5、NaN（无法计算结果时出现，表示"非数值"；但是typeof NaN==="number"）

6、""（双引号）或''（单引号）

ECMAScript Boolean对象

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true; //输出 true
在这段代码中，用 false 值创建 Boolean 对象。
然后用这个值与原始值 true 进行 AND 操作。
在 Boolean 运算中，false 和 true 进行 AND 操作的结果是 false。
不过，在这行代码中，计算的是 oFalseObject，而不是它的值 false。
正如前面讨论过的，在 Boolean 表达式中，所有对象都会被自动转换为 true，
所以 oFalseObject 的值是 true。然后 true 再与 true 进行 AND 操作，结果为 true。

JavaScript 数组

JavaScript 数组用方括号书写。
数组的项目由逗号分隔。
var cars = ["Porsche", "Volvo", "BMW"];

数字数组排序

function sortNumber(a, b)
{
return b - a // 如果换成a - b 就会从小到大排序
}

var arr = new Array(6)
arr[0] = "10"
arr[1] = "5"
arr[2] = "40"
arr[3] = "25"
arr[4] = "1000"
arr[5] = "1"
document.write(arr + "<br>") //10,5,40,25,1000,1
document.write(arr.sort(sortNumber)) //1000,40,25,10,5,1

也可以写成numbers.sort((a, b) => b - a);

字符数组排序

function compare(a, b) {

  if (a < b ) {           // 按某种排序标准进行比较, a 小于 b

    return -1;//如果这里是1，下面是-1那就按相反方向

  }

  if (a > b ) {

    return 1;

  }

  // a must be equal to b

  return 0;

var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"
document.write(arr + "<br />") // George,John,Thomas,James,Adrew,Martin
document.write(arr.sort(compare)) // Adrew,George,James,John,Martin,Thomas字母表顺序

ECMAScript Array 对象

属性 描述
constructor 返回对创建此对象的数组函数的引用。
length 设置或返回数组中元素的数目。
prototype 向对象添加属性和方法。
Array 对象方法
方法 描述
concat() 连接两个或更多的数组，并返回结果。
join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
默认用逗号隔开
pop() 删除并返回数组的最后一个元素
push() 向数组的末尾添加一个或更多元素，并返回新的长度。
reverse() 颠倒数组中元素的顺序。
shift() 删除并返回数组的第一个元素
slice() 从某个已有的数组返回选定的元素
splice() 删除元素，并向数组添加新元素。
toSource() 返回该对象的源代码。
toString() 把数组转换为字符串，并返回结果。
toLocaleString() 把数组转换为本地数组，并返回结果。
unshift() 向数组的开头添加一个或更多元素，并返回新的长度。
valueOf() 返回数组对象的原始值
注意：str.split(",") 可以将中间带有,的字符串转换成数组形式。

JavaScript 对象

JavaScript 对象用花括号来书写。
对象属性是 name:value 对，由逗号分隔。
var person = {firstName:"Bill", lastName:"Gates", age:62, eyeColor:"blue"};

ECMAScript Object 对象具有下列属性：

constructor
对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数。
Prototype
对该对象的对象原型的引用。对于所有的对象，它默认返回 Object 对象的一个实例
Object 对象还具有几个方法：
hasOwnProperty(property)
判断对象是否有某个特定的属性。必须用字符串指定该属性。（例如，o.hasOwnProperty("name")）
IsPrototypeOf(object)
判断该对象是否为另一个对象的原型。
PropertyIsEnumerable
判断给定的属性是否可以用 for...in 语句进行枚举。
ToString()
返回对象的原始字符串表示。对于 Object 对象，ECMA-262 没有定义这个值，所以不同的 ECMAScript 实现具有不同的值。
ValueOf()
返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同。
注释：上面列出的每种属性和方法都会被其他对象覆盖。

typeof 运算符
您可使用 JavaScript 的 typeof 来确定 JavaScript 变量的类型
typeof "" // 返回 "string"
typeof "Bill" // 返回 "string"
typeof "Bill Gates" // 返回 "string"
typeof 0 // 返回 "number"
typeof 314 // 返回 "number"
typeof 3.14 // 返回 "number"
typeof (7) // 返回 "number"
typeof (7 + 8) // 返回 "number"
typeof(NaN)
// 返回"number"

typeof(undefined)
// 返回"undefined"
typeof(null) // 返回"object"
typeof 运算符对数组返回 "object"，因为在 JavaScript 中数组属于对象。

instanceof 运算符
在使用 typeof 运算符时采用引用类型存储值会出现一个问题，
无论引用的是什么类型的对象，它都返回 "object"。ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。
instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。
与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型
var oStringObject = new String("hello world");
alert(oStringObject instanceof String); //输出 "true"
这段代码问的是“变量 oStringObject 是否为 String 对象的实例？”
oStringObject 的确是 String 对象的实例，因此结果是 "true"。
尽管不像 typeof 方法那样灵活，但是在 typeof 方法返回 "object" 的情况下，instanceof 方法还是很有用的。

Undefined
在 JavaScript 中，没有值的变量，其值是 undefined
var person; // 值是 undefined，类型是 undefined
person = undefined; // 值是 undefined，类型是 undefined

Null
在 JavaScript 中，null 是 "nothing"。它被看做不存在的事物。
您可以把 null 在 JavaScript 中是对象理解为一个 bug。它本应是 null。
您可以通过设置值为 null 清空对象
var person = null; // 值是 null，但是类型仍然是对象
Undefined 与 null 的值相等，但类型不相等

数字转换成字符串的方法

var iNum = 10;
alert(iNum.toString()); //输出 "10"
alert(iNum.toString(2)); //输出 "1010"
alert(iNum.toString(8)); //输出 "12"
alert(iNum.toString(16)); //输出 "A"

字符串转换成数字的方法

parseInt() 方法首先查看位置 0 处的字符，判断它是否是个有效数字；
如果不是，该方法将返回 NaN，不再继续执行其他操作。
但如果该字符是有效数字，该方法将查看位置 1 处的字符，进行同样的测试。
这一过程将持续到发现非有效数字的字符为止，此时 parseInt() 将把该字符之前的字符串转换成数字。
var iNum1 = parseInt("12345red"); //返回 12345
var iNum1 = parseInt("0xA"); //返回 10
var iNum1 = parseInt("56.9"); //返回 56
var iNum1 = parseInt("red"); //返回 NaN
var iNum1 = parseInt("10", 2); //返回 2=1*2+0
var iNum2 = parseInt("10", 8); //返回 8=1*8+0
var iNum3 = parseInt("10", 10); //返回 10=1*10+0
var iNum1 = parseInt("AF", 16); //返回 175=10*16+15（A代表10，F代表15）
var iNum1 = parseInt("010"); //返回 8（因为前导 0）
var iNum2 = parseInt("010", 8); //返回 8
var iNum3 = parseInt("010", 10); //返回 10

parseFloat()
parseFloat() 方法与 parseInt() 方法的处理方式相似，、
从位置 0 开始查看每个字符，直到找到第一个非有效的字符为止，
然后把该字符之前的字符串转换成整数
var fNum1 = parseFloat("12345red"); //返回 12345
var fNum2 = parseFloat("0xA"); //返回 NaN
var fNum3 = parseFloat("11.2"); //返回 11.2
var fNum4 = parseFloat("11.22.33"); //返回 11.22
var fNum5 = parseFloat("0102"); //返回 102
var fNum1 = parseFloat("red"); //返回 NaN

强制类型转换

Boolean() 函数
当要转换的值是至少有一个字符的字符串、非 0 数字或对象时，Boolean() 函数将返回 true。
如果该值是空字符串、数字 0、undefined 或 null，它将返回 false
var b1 = Boolean(""); //false - 空字符串
var b2 = Boolean("hello"); //true - 非空字符串
var b1 = Boolean(50); //true - 非零数字
var b1 = Boolean(null); //false - null
var b1 = Boolean(0); //false - 零
var b1 = Boolean(new object()); //true - 对象

Number() 函数
Number()函数的强制类型转换与 parseInt() 和 parseFloat() 方法的处理方式相似。
只是它转换的是整个值，而不是部分值。
Number(false) //0
Number(true) //1
Number(undefined) //NaN
Number(null) //0
Number("1.2") //1.2
Number("12") //12
Number("1.2.3") //NaN
Number(new object()) //NaN
Number(50) //50

String() 函数
最后一种强制类型转换方法 String() 是最简单的，类似于 toString() 方法
因为它可把任何值转换成字符串。
强制转换成字符串和调用 toString() 方法的唯一不同之处在于，
对 null 和 undefined 值强制类型转换可以生成字符串而不引发错误：
var s1 = String(null); //"null"
var oNull = null;
var s2 = oNull.toString(); //会引发错误

判断input输入框是否为数值

function isNumber(str) {
// 利用正则表达式判断不是空值和空格，isNaN()函数判断不是数字。反之，就返回为数值形式。
if((/^[ ]*$/).test(str) || isNaN(str)) {
console.log("输入内容不是数字");
} else {
return Number(str);
}
}
//也可以用正则表达式(/^[0-9]+.[0-9]*$/)匹配数值

判断一个字符在字符串出现的次数

// 参数1正则式，也可以是字符，参数2字符串
function patch(re,str) {
// 不区分大小写，如须则去掉i,改为 re=eval("/"+re+"/g")
re=eval("/"+re+"/ig")
return str.match(re).length;
}

//通过分隔符把字符串分成几段，减一次就是字符出现的次数
function counts(re, str) {
return (str.split(re)).length-1;
}

字符串替换一个和替换全部

strA.value.replace(" ", "") // 替换一个空格
strA.value.replace(/ /g, "") // 替换全部空格

strB.value.replace("a", strC) // 替换一个a
strB.value.replace(/a/g, strC) // 替换全部a
strB.value.replace(/a/ig, strC) //替换全部a和A，ig表示不区分大小写。