字符串、数组、数组的其他方法、数组的排序

String

// 使用字面量创建字符串
var str1 = 'web';
var str2 = "web";
console.log(str1, str2);
console.log(typeof str1, typeof str2);

// 使用构造函数创建字符串
var str3 = new String('abc');
console.log(str3); // 02-string.html:18 String {"abc"}
console.log(typeof str3); // object

length：字符串的长度，每个字符都会占一个长度。字符串的下标从0开始，到length-1
charAt(下标)：返回下标对应的字符
charCodeAt(下标)：获取对应下标的字符编码 0:48 A:65 a:97
indexOf(str[,index])：返回某个指定的字符串在目标字符串中首次出现的位置。找不到就返回-1。
lastIndexOf()：返回某个指定的字符串在目标字符串中最后一次出现的位置。找不到就返回-1。
split(分隔符[,数组的长度])：把字符串使用指定的分隔符切割成数组，可以指定返回的数组的长度。
toLowerCase(): 小写
toUpperCase(): 大写
replace()：字符串的替换，接受两个参数，第一个参数是将要被替换的内容，第二个参数是替换的新内容
trim(): 去掉字符串的左右空格，不兼容IE8及以下

// length：字符串的长度，每个字符都会占一个长度。
var str = 'abc123哈哈哈 !.abc';
console.log(str.length);

// 字符串的下标从0开始，到length-1
// charAt(下标)：返回下标对应的字符
console.log(str.charAt(0)); // a
console.log(str.charAt(str.length-1)); // .
console.log(str.charAt(str.length)); // ''
console.log(str.charAt(-100));  // ''

// charCodeAt(下标)：获取对应下标的字符编码 0:48 A:65 a:97
console.log(str.charCodeAt(0)); // 97
console.log(str.charCodeAt(1)); // 98

// indexOf(str[,index])：返回某个指定的字符串在目标字符串中首次出现的位置。找不到就返回-1。
console.log(str.indexOf('a')); // 0
console.log(str.indexOf('a', 3)); // 12
console.log(str.indexOf('x')); // -1

// lastIndexOf()：返回某个指定的字符串在目标字符串中最后一次出现的位置。找不到就返回-1。
console.log(str.lastIndexOf('a')); // 12
console.log(str.lastIndexOf('a', 5)); // 0
console.log(str.lastIndexOf('x')); // -1

// split(分隔符[,数组的长度])：把字符串使用指定的分隔符切割成数组，可以指定返回的数组的长度。
var str = 'abcabcac';
var arr = str.split('b');
console.log(arr); // ["a", "ca", "cac"]
console.log(str);
var arr1 = str.split();
console.log(arr1); // 04-split.html:16 ["abcabcac"]
var arr2 = str.split('');
console.log(arr2); // ["a", "b", "c", "a", "b", "c", "a", "c"]
var arr3 = str.split('', 3);
console.log(arr3); // 04-split.html:20 (3) ["a", "b", "c"]

// toLowerCase(): 小写
// toUpperCase(): 大写
var str = 'abc';
console.log(str.toUpperCase()); // ABC
var str1 = 'ABC';
console.log(str1.toLowerCase()); // abc

// replace()：字符串的替换，接受两个参数，第一个参数是将要被替换的内容，第二个参数是替换的新内容
var str = 'abc123';
console.log(str.replace('123', 'xyz'));

// trim(): 去掉字符串的左右空格，不兼容IE8及以下
var str = '  a b c  ';
console.log(str.trim()); // 'a b c'
console.log(str); // '  a b c  '

substring(start, stop): 截取字符串，参数可选，从start位置截取到stop的位置，不包括stop位置
slice(start, stop): 用法与substring一致
substr(start, length): 从start开始截取，截取length个

var str = 'abcdef';
// substring(start, stop): 截取字符串，参数可选，从start位置截取到stop的位置，不包括stop位置
console.log(str.substring(1, 3)); // bc
console.log(str.substring(1)); // bcdef
console.log(str.substring()); // abcdef

// slice(start, stop): 用法与substring一致
console.log(str.slice(1, 3)); // bc
console.log(str.slice(1)); // bcdef
console.log(str.slice()); // abcdef

// 当出现负数：
console.log(str.substring(-3, 5)); // abcde substring自动变为0
console.log(str.slice(-4, 5)); // cde slice会把负数+字符串长度
console.log(str.slice(-20, 5)); // abcde slice会把负数+字符串长度还是负数变为0

// 当开始位置大于结束位置
console.log(str.substring(5, 3)); // de substring会自动调换位置
console.log(str.slice(5, 3)); // '' slice不会自动调换位置


// substr(start, length): 从start开始截取，截取length个
console.log(str.substr(1, 3)); // bcd
console.log(str.substr(1)); // bcdef
// 负数代表倒数
console.log(str.substr(-3)); // def

数组

数组：有序的数据集合。数组中可以存放任意数据类型，一般会存放同一类型的数据。
数组可以使用字面量创建
数组也可以使用构造函数创建

// 数组：有序的数据集合。数组中可以存放任意数据类型，一般会存放同一类型的数据。
var arr = [1, 2, 3];
// var arr = [1, null, true, 'haha', function () {}];
console.log(arr);
console.log(typeof arr); // object

var arr1 = new Array(1, 2, 3, 4, 5);
console.log(arr1);
console.log(typeof arr1);
// 在使用构造函数创建对象时，如果只有一个参数并且是数字，这个数字表示数组的长度。
var arr2 = new Array(3);
console.log(arr2); // (3) [empty × 3]
var arr3 = new Array('haha');
console.log(arr3); // ["haha"]

length：数组的长度，表示数组中元素的个数，length属性可读可写。

// length：数组的长度，表示数组中元素的个数，length属性可读可写。
var arr = [1, 2, 3];
console.log(arr.length);
arr.length = 100;
console.log(arr.length);
console.log(arr); // (100) [1, 2, 3, empty × 97]
arr.length = 1;
console.log(arr); // [1]

数组的遍历

var arr = [1, 2, 3, 4, 5, 6];
for (var i = 0; i < arr.length; i++) {
    
    
    console.log(arr[i]);
}

数组的方法

push()：在数组的尾部添加元素并返回数组的新长度
pop()：删除数组的尾部元素并返回该元素
unshift()：头部添加元素并返回数组的新长度
shift()：头部删除元素并返回该元素

var arr = ['八万', '九筒', '幺鸡', '东风'];
var s = arr.push('五万');
console.log(arr, s);

var s = arr.pop();
console.log(arr, s);

var s = arr.unshift('白板');
console.log(arr, s);

var s = arr.shift();
console.log(arr, s);

splice(start, deleteCount, items)：多功能（添加，删除，替换）

// splice(start, deleteCount, items)：多功能（添加，删除，替换）
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];

// 两个参数，第一个是开始的位置，第二个是删除的个数，把删除的元素以数组的形式返回
var s = arr.splice(1, 3);
console.log(arr, s); // (6) [1, 5, 6, 7, 8, 9] (3) [2, 3, 4]

// 替换元素
s = arr.splice(1, 1, 'a', 'b', 'c');
console.log(arr, s); // (8) [1, "a", "b", "c", 6, 7, 8, 9] [5]

// 添加元素
s = arr.splice(1, 0, 'haha', 'xixi');
console.log(arr, s); // (10) [1, "haha", "xixi", "a", "b", "c", 6, 7, 8, 9] []

数组的其他方法

join()：把数组拼接成字符串，接受一个参数（分隔符）。
concat(): 拼接数组，接受单个元素或者数组作为参数，不会影响原数组，返回新数组。
reverse(): 倒序
indexOf(): 查找目标元素的下标，第二个参数为开始查找元素的位置
slice(start, end): 截取数组，对原数组没有影响，返回新数组。
Array.isArray(): 判断是否为数组

// join()：把数组拼接成字符串，接受一个参数（分隔符）。
var arr = [1, 2, 3, 4, 5, 6];
var s = arr.join();
console.log(arr, s); // [1, 2, 3, 4, 5, 6] "1,2,3,4,5,6"
var s1 = arr.join('-');
console.log(arr, s1); // [1, 2, 3, 4, 5, 6] "1-2-3-4-5-6"
var s2 = arr.join('');
console.log(arr, s2); // [1, 2, 3, 4, 5, 6] "123456"

// concat(): 拼接数组，接受单个元素或者数组作为参数，不会影响原数组，返回新数组。
var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = ['a', 'b', 'c'];
var s = arr1.concat(7, 8, arr2);
console.log(arr1, arr2, s); // (6) [1, 2, 3, 4, 5, 6] (3) ["a", "b", "c"] (11) [1, 2, 3, 4, 5, 6, 7, 8, "a", "b", "c"]

// reverse(): 倒序
var arr = [1, 2, 3, 4, 5, 6];
arr.reverse();
console.log(arr); // [6, 5, 4, 3, 2, 1]

// indexOf(): 查找目标元素的下标，第二个参数为开始查找元素的位置
var arr = ['a', 'b', 'c', 'a', 'b', 'c'];
console.log(arr.indexOf('a')); // 0
console.log(arr.indexOf('a', 1)); // 3

// slice(start, end): 截取数组，对原数组没有影响，返回新数组。
var arr = [1, 2, 3, 4, 5, 6];
var s = arr.slice(1, 3);
console.log(arr, s); // (6) [1, 2, 3, 4, 5, 6] (2) [2, 3]

// Array.isArray(): 判断是否为数组
var arr = [1, 2, 3, 4, 5, 6];
console.log(Array.isArray(arr));
var a = 123;
console.log(Array.isArray(a));

数组的排序

选择排序：从第一项开始，每项都与后面的所有项进行比较，如果前面的大于后面的两者进行互换位置。

// 选择排序：从第一项开始，每项都与后面的所有项进行比较，如果前面的大于后面的两者进行互换位置。
var arr = [6, 5, 9, 1, 3, 2, 4, 8, 7];
for (var i = 0; i < arr.length; i++) {
    
    
    for (var j = i + 1; j < arr.length; j++) {
    
    
        if (arr[i] < arr[j]) {
    
    
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    console.log(arr);
}
// 第一次：[1, 6, 9, 5, 3, 2, 4, 8, 7] 第一次确定最小的1
// 第二次：[1, 2, 9, 6, 5, 3, 4, 8, 7] 第二次确定第二小的2
console.log(arr);

冒泡排序：从第一项开始，每相邻两项进行比较，如果前面大于后面两者交换位置

// 冒泡排序：从第一项开始，每相邻两项进行比较，如果前面大于后面两者交换位置
var arr = [6, 5, 9, 1, 3, 2, 4, 8, 7];
// 第一次：[5, 6, 1, 3, 2, 4, 8, 7, 9] 第一次确定了最大的9
for (var i = 0; i < arr.length; i++) {
    
    
    for (var j = 0; j < arr.length - i; j++) {
    
    
        if (arr[j] > arr[j+1]) {
    
    
            var temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
    console.log(arr);
}
console.log(arr);

sort()：数组排序，默认按照字符编码排序。

// var arr = [6, 5, 9, 1, 3, 2, 4, 8, 7, 11, 111, 66, 666];
// arr.sort();
// console.log(arr); // 16-sort().html:12 (13) [1, 11, 111, 2, 3, 4, 5, 6, 66, 666, 7, 8, 9]

// var arr = [6, 5, 9, 1, 3, 2, 4, 8, 7, 11, 111, 66, 666];
// arr.sort(function (a, b) {
    
    
//     return a - b; // 升序
//     // return b - a; // 降序
// });
// console.log(arr); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 66, 111, 666]

var arr = [
    {
    
    
        name: '张宁',
        age: 18
    },
    {
    
    
        name: '陆生',
        age: 21
    },
    {
    
    
        name: '国亮',
        age: 20
    }
];
arr.sort(function (a, b) {
    
    
    // return a.age - b.age;
    return a.name.localeCompare(b.name, 'zh');
});
console.log(arr);

字符串、数组、数组的其他方法、数组的排序

String

数组

数组的方法

数组的其他方法

数组的排序

猜你喜欢