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表示不區分大小寫。