首页 > 其他分享> 文章详细

发布博文测试

2022-06-26 21:34:36 阅读：128 来源： 互联网

标签：Map arr Set name age 博文发布测试 var

测试测试博文内容发布

总是执着想学各种框架，但忘了基础学好才最重要。每次打开菜鸟教程想重温基础内容，然后就像翻开英文字典，永远在abandon...还是需要做个笔记。

一来加深学习印象，二来等下次打开学习可以知道自己上次学到哪里了。就不至于abandon了。

JS可以放在任何地方，通常放在<head> <script></script> </head>中，或者外部引入

JS调试可在Chrome浏览器 --> 开发者工具 --> Console控制台中使用Console.log(); 打印查看内容

基本语法

每个语句以;结尾，中间语句块使用{...}

//...为行注释，/* ... */为块注释

JavaScript严格区分大小写

数据类型和变量

值类型(基本类型)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol。(Symbol 是 ES6 引入了一种新的原始数据类型，表示独一无二的值。)

引用数据类型：对象(Object)、数组(Array)、函数(Function)。

JS中数值类型不区分整数和浮点数，统一用Number。
字符串用单引号双引号
布尔值 true false
比较运算符 > >= ==

要特别注意相等运算符==。JavaScript在设计时，有两种比较运算符：

第一种是==比较，它会自动转换数据类型再比较，很多时候，会得到非常诡异的结果；// false==0 (结果为true)

第二种是===比较，它不会自动转换数据类型，如果数据类型不一致，返回false，如果一致，再比较。// false===0 (结果为false)

由于JavaScript这个设计缺陷，不要使用==比较，始终坚持使用===比较。

另一个例外是NaN这个特殊的Number与所有其他值都不相等，包括它自己 // NaN === NaN; (结果为false)

唯一能判断NaN的方法是通过isNaN()函数 // isNaN(NaN); (结果为true)

最后要注意浮点数的相等比较：

1 / 3 === (1 - 2 / 3); // false
这不是JavaScript的设计缺陷。浮点数在运算过程中会产生误差，因为计算机无法精确表示无限循环小数。要比较两个浮点数是否相等，只能计算它们之差的绝对值，看是否小于某个阈值：

Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true

null表示空，与0和' '不同，0是数值，' '表示长度为0的字符串。

数组

[1,2,3,null,'hello'] 或 new Array(1,2,3);//创建 [1,2,3] 的数组
var arr=[1,2,3,null,'hello']; //arr(0) 返回为1 ,arr(4) 返回为hello

对象

以键-值方式组成的无序集合

var person = {
    name: 'Bob',
    age: 20,
    tags: ['js', 'web', 'mobile'],
    city: 'Beijing',
    hasCar: true,
    zipcode: null
};

获取对象的属性
person.name;//Bob

变量

变量名是大小写英文、数字、$和_的组合，且不能用数字开头，也不能是关键字。

var a; // 申明了变量a，此时a的值为undefined
var $b = 1; // 申明了变量$b，同时给$b赋值，此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null

操作字符串

var s = 'Hello, world!';
s.length; // 13

需要特别注意的是，字符串是不可变的，如果对字符串的某个索引赋值，不会有任何错误，但是，也没有任何效果：

var s = 'Test';
s[0] = 'X';
alert(s); // s仍然为'Test'

JavaScript为字符串提供了一些常用方法，注意，调用这些方法本身不会改变原有字符串的内容，而是返回一个新字符串：

toUpperCase() //转为大写

var s='hello world'; var up=s.toUpperCase();

toLowerCase() //转为小写

indexOf() //搜索指定字符串出现的位置

var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 没有找到指定的子串，返回-1

substring() // 返回指定索引区间的子串：

var s = 'hello, world'
s.substring(0, 5); // 从索引0开始到5（不包括5），返回'hello'
s.substring(7); // 从索引7开始到结束，返回'world'

slice是对应字符串(String)的substring()版本

push()向数组(Array)的末尾添加元素，pop()则是把末尾最后一个元素删除

var arr=[ 1 , 2 ];
arr.push('A' , 'B');
console.log(arr); //输出为[ 1, 2, A, B]
console.log(arr.pop()); // 输出为B
console.log(arr); // 输出为[ 1, 2, A]

unshift ()像数组头部添加元素，shift ()则是把头部第一个元素删除

sort()对元素进行排序，直接调用时则默认顺序排列

var arr=new Array(2, 5, 1, 8);
console.log(arr.sort()); // 显示 1 2 5 8

reverse()则是把顺序反转

var arr = ['one', 'two', 'three'];
arr.reverse(); 
arr; // ['three', 'two', 'one']

splice()从指定位置删除若干元素，再从该位置开始添加一些元素

var arr=['Hello', 'This', 'And', ‘You’, 'Nice', 'To', 'meet'];
arr.splice(1, 3, 'World', '!'); // 表示从下标为1的元素开始，删除3个元素，添加两个元素，即删除了This，And，You
arr; // ['Hello', 'World', '!', 'Nice', 'To', 'meet'];

concat()将两个数组连接起来，返回一个新的数组

var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']

join()方法能将数组中的每个元素都连接起来

var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'

多维数组

var arr = [[1, 2, 3], [400, 500, 600], '-'];//该数组包含3个元素，其中头两个元素本身也是Array数组

对象

javascript的对象是一种无序的集合数据类型，由一些键值对组成

var xiaoming = {
    name: '小明',
    birth: 1990,
    school: 'No.1 Middle School',
    height: 1.70,
    weight: 65,
    score: null
};

使用{...}来表示一个对象，属性名：值的方式来表示，使用,来隔开，最后一个不需要加,因为容易造成低版本浏览器的不兼容。

xiaoming.name;//获取到`小明`这个值
xiaoming.weight;//获取到`65`

属性名若是特殊字符，则用' '引号表示起来

var xiaohong = {
    name: '小红',
    'middle-school': 'No.1 Middle School'
};

获取该特殊属性的方式如下：

xiaohong['middle-school']; //获取到'No.1 Middle School'
xiaohong['name'];   xiaohong.name;   //这两种方式都获取到值`小红`

当访问一个不存在的属性时，返回为undefined；例如xiaohong.age;将提示undefined

javascript的对象是动态的，即可以自由的为其对象进行增加/删除属性
如上方获取xiaohong.age;将提示undefined。
当给其赋值 xiaohong.age=18; 再输出 xiaohong.age; 则获取到值18
删除属性： delete xiaohong.name;

检测该对象是否拥有该属性可使用in
'name' in xiaohong; //返回true
'age' in xiaohong; //false
使用in判断出的属性也可能是该对象由继承得到的。

要判断该属性是否其自身所拥有，可使用hasOwnProperty()
xiaohong.hasOwnProperty('name'); //true

条件判断

使用if...else

var age = 20;
if (age >= 18) { // 如果age >= 18为true，则执行if语句块
    alert('adult');
} else { // 否则执行else语句块
    alert('teenager');
}

if...else if...else多行条件判断

var age = 3;
if (age >= 18) {
    alert('adult');
} else if (age >= 6) {
    alert('teenager');
} else {
    alert('kid');
}

循环

for循环

var x = 0;
var i;
for (i=1; i<=10000; i++) {
    x = x + i;
}
x; // 50005000

for...in将对象的属性循环出来

var o = {
    name: 'Jack',
    age: 20,
    city: 'Beijing'
};
for (var key in o) {
    console.log(key); // 'name', 'age', 'city'
}

循环数组中的对象属性

var a = ['A', 'B', 'C'];
for (var i in a) {
    console.log(i); // '0', '1', '2'
    console.log(a[i]); // 'A', 'B', 'C'
}

还有while 循环和do..while 循环

Map和Set

用键值对表示对象时，其属性必须为字符串类型；但实际上Number或者其他数据类型作为键也是非常合理的。所以在ES6中引入了新的数据类型Map

举例
要查找某个同学的分数时，通常如下表示方式

var names = ['Michael', 'Bob', 'Tracy'];
var scores = [95, 75, 85];

给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，Array越长，耗时越长。

如果用Map实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢

var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95

Map有以下的方法

var m = new Map();
m.set('name1',97);
m.set('name2',66);
m.has('name1'); //返回为true，即表示存在该name1的键
m.get('name1'); //返回为 97
m.delete('name1'); //删除name1的键
m.get('name1'); //再获取则显示 undefined

一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

var m = new Map();
m.set('Adam', 67);
m.set('Adam', 88);
m.get('Adam'); // 88

Set

Set和Map类似，也是一组key的集合，但不存储value

var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3

重复元素在Set中自动被过滤：

var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"}

通过add(key)方法可以添加元素到Set中，可以重复添加，但不会有效果：

s.add(4);
s; // Set {1, 2, 3, 4}
s.add(4);
s; // 仍然是 Set {1, 2, 3, 4}

通过delete(key)方法可以删除元素：

var s = new Set([1, 2, 3]);
s; // Set {1, 2, 3}
s.delete(3);
s; // Set {1, 2}

iterable

遍历数组可以采用下标循环，遍历Map和Set就无法使用下标。为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。
具有iterable类型的集合可以通过for ... of（是ES6的新语法）循环来遍历

var a = ['A','B','C'];
var s = new Set(['A','B','C']);
var m = new Map(['A',1],['B',2],['C',3]);
for (var x of a) { // 遍历Array
    console.log(x); //A B C
}
for (var x of s) { // 遍历Set
    console.log(x); //A B C
}
for (var x of m) { // 遍历Map
    console.log(x[0] + '=' + x[1]); A=1 B=2 C=3
}

相比于前两种循环输出，可以使用forEach()

var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
    // element: 指向当前元素的值
    // index: 指向当前索引
    // array: 指向Array对象本身
    console.log(element + ', index = ' + index);
});
// 输出 
// A, index = 0
// B, index = 1
// C, index = 2

标签：Map,arr,Set,name,age,博文,发布,测试,var
来源： https://www.cnblogs.com/songyan/p/16414385.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9