js基础

最新推荐文章于 2022-11-23 17:32:46 发布

你得握有刀剑

最新推荐文章于 2022-11-23 17:32:46 发布

阅读量105

点赞数

分类专栏： javaee

本文链接：https://blog.csdn.net/qq_39027486/article/details/100216711

版权

javaee 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

js基础

js基本概念

js是什么？
JavaScript 浏览器前端的脚本语言

特点:

跨平台
基于对象
弱语言 …

js解决的问题?
网页和浏览器有更好的交互

js的学习?
1、基本语法
2. dom操作
3. 表单验证

js的入门程序:
在html 文档中添加是script标签写js代码
alert(); 弹框
console.log() 控制台的输出

变量:
js是弱语言不用声明数据类型
变量声明语法:
var 变量名称 = 值;
全局变量: 在方法外部声明的变量
局部变量:方法内部，使用var声明的变量

js的数据类型:
变量是没有类型的，数据是有类型的。常用的有如下6种类型：
六种类型
1、undefined未定义 (声明了变量但从未赋值 )
2、null空 (赋值为null)
3、boolean布尔型 (true,false)
4、字符串string (单引号、双引号均可)
5、数值number
包括整数和小数，NaN（Not a Number），Infinity, -Infinity
6、对象object
使用typeof可以得出数据类型

/**
1.如果一个操作值为布尔值，则在比较之前先将其转换为数值
2.如果一个操作值为字符串，另一个操作值为数值，则通过Number()函数将字符串转换为数值
3.如果一个操作值是对象，另一个不是，则调用对象的valueOf() toString()方法，
得到的结果按照前面的规则进行比较
4.null与undefined是相等的
5.如果一个操作值为NaN，则相等比较返回false
6.如果两个操作值都是对象，则比较它们是不是指向同一个对象
NaN是js中唯一一个自己不等于自己的数据，可以用来判断是否是NaN类型

js的三种写法

1、在外部文件

		<!-- script 标签 引入 外部js文件 
			src 外部文件的路劲
			
			引入外部文件 不要在 script标签中写入其他的js代码
			
		-->
		<!--<script type="text/javascript" src="../js/my.js" >
		    //这里不要写代码 
		</script>-->

2、在内部head中/在head和body之间

		<!--<script>
			// 代码 可以网页 嵌套
			alert("hello world ");
            // js文件可以写在 外部  通过 src 引入js文件
            
		</script>-->

3、写在body中

		<p onclick="alert('点我干啥')">点我</p>

案例：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8" />
		<title></title>
		<!--<script>
			alert("hello");	//显示一个弹出框
		</script>-->
		<script type="text/javascript" src="js/te.js"></script>
	</head>
	<body>
		<!--<p onclick="alert('check')">点我</p>-->
	</body>
</html>

js文件：

alert("woshi waimian");

js的属性：

在这里插入图片描述

案例

变量声明直接用var即可：

<script type="text/javascript">
		// js 中变量的声明  弱语言  不用声明数据类型 
		//   都是使用关键字 var 来声明变量 
		var a = 12; //数字 
		var b = "张三";
		var c = new Date();
		console.log(a); // 控制台打印
		console.log(b); // 控制台打印
		console.log(c); // 控制台打印
		
		var d;
		console.log(d);// 定义了变量没有赋值是 undefined
		
		// 全局变量 
		var  num = 100;
		
		//定义一个方法 
		function test(){
			//局部变量  
			var num = 200;
			console.log(num);
		}
		
	</script>

	<script>
		var a=null;
		var c=true;
		//字符串单双引号都行
		var str1="hello";
		var str2="world";
		console.log(str1+"->"+str2);
		var n1=12;
		var n2=3.14;
		var n3=parseInt("asd111");//结果NaN 赋值给变量n3 
		var n4=n1/0;// 无穷大-》Infinity
		var obj1=new Date();
		console.log(obj1);
		console.log(typeof obj1);//属于object对象
		console.log(n1);
		console.log(n2);
		console.log(n3);
		console.log(n4);	//Infinity
	</script>

boolean转换为number
String转换为number
null和false的转换

	<script>
		var a=false;
		console.log(Number(a));//将boolean转换为number
		var b="123";//str可以转换为数字10进制
		var c=parseInt(b);//以下两个方法都能转换为数字
		var d=Number(b);		
		console.log(typeof(d));
		console.log(typeof(c));
	</script>

		var a=true;
		console.log(a+a);//先自动准换为number，再相加等于2
		var b=true;
		console.log(b+"asd");//先自动转换为String在字符串拼接，trueasd
	
		if("123"==123)//进行判断时会自动类型转换
		{console.log("转换成功！")}
		//false-》0
		console.log(false+2);//boolean转为0再相加：2
		
		var a=null;
		if(!a){//null->false
			console.log("null->false");
		}
		var b;
		if(!b){//undefined->false
			console.log("undefined转成了false");
		}

关于==和===

==是比较值是否相等
过程：相同类型则比较内容，不同类型则优先转换为number/string在进行比较
===是先比较类型再比较内容
但两者都不会改变原来的类型

		var a1=123;
		var a2="123";//先比类型，类似于java中的instanceof在比较值
		if(a1===a2){
		console.log("先比较类型在比较值")}//这句话不打印
		if(a1==a2)//只比较值的内容，且两个数据类型不变
		{
			console.log("只比较值");//打印
			console.log(typeof(a1));//number
			console.log(typeof(a2));//String
		}

js中其他相等的判断：


	'' == '0'   //类型相同，比较值，值不同，所以false  

	0 == '' //类型不同，String转Number，空字符串转为0，变成0==0，所以true  

	0 == '0'    //类型不同，String转Number，'0'转成0，变成0==0，所以true  

	false == 'false'    //类型不同，Boolean转Number，即0=='false'，然后'false'转Number，为0==NaN,所以false  

	false == '0'    //类型不同，Boolean转Number，即0=='0'，就变成第3个例子，所以true  

	false == undefined  //对于undefined和null，只有它们本身两个比较才是true，其他都是false，所以false  

	false == null   //对于undefined和null，只有它们本身两个比较才是true，其他都是false，所以false  

	null == undefined   //对于undefined和null，只有它们本身两个比较才是true，其他都是false，所以true  

	true == 2   //类型不同，Boolen转Number，即1==2，所以false  

	NaN == NaN  //NaN非常特殊，和自身也不相等，所以false  

	' \t\r\n ' == 0 //类型不同，String转Number，空String都将转成0，即0==0,所以true  

	0 == [] //对象类型[]调用toString()转为""，即0==""，即0==0，所以true  

	0 == ['']   //对象类型['']调用toString()转为""，即0==""，即0==0，所以true  

	'0' == []   //对象类型[]调用toString()转为""，即'0'==""，类型相同，值不同，所以false  

	'0' == [0]  //对象类型[0]调用toString()转为"0"，即'0'=="0"，类型相同，值也相同，所以true  

	true == [1] //对象类型[1]调用toString()转为"1"，即1=="1"，转1==1，所以true  

	[] == []    //对象类型，比较引用地址，两个[]是不同的引用地址，所以false  

	![] == []   //加!强制转Boolean，任何对象都是true，取反即false==[]，转为0==""，即0==0，所以true  

	{} == {}    //对象类型，比较引用地址，两个{}是不同的引用地址，所以false  

	!{} == {}   //即false=={}，转为false=="[object Object]"，即0==NaN，所以false