js学习day05

最新推荐文章于 2024-10-22 15:32:57 发布

Aitting

最新推荐文章于 2024-10-22 15:32:57 发布

阅读量94

点赞数

分类专栏： JavaScript

本文链接：https://blog.csdn.net/m0_45483025/article/details/107193375

版权

JavaScript 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

<!DOCTYPE html>
<html>
 <head>
  <meta charset="utf-8" />
  <title></title>
  <script type="text/javascript">
   
   /*
    
      通过程序，在页面中输出如下的图形：
      
      *      1   <1   i=0
      **     2   <2   i=1
      ***    3   <3   i=2
      ****   4   <4   i=3
      *****  5   <5   i=4
      
      *****
      *****
      *****
      *****
      *****
      
      ***** 1   j<5(5-0)  i=0
      ****  2    j<4(5-1)  i=1
      ***   3   j<3(5-2)  i=2
      **    4   j<2(5-3)  i=3
      *     5   j<1(5-4)  i=4
      
    
    */
   
   //向body中输出一个内容
   //document.write("*****<br />");
   
   //通过一个for循环来输出图形
   //这个for循环执行几次，图形的高度就是多少
   //它可以用来控制图形的高度
   for(var i=0 ; i<5 ; i++){
    
    /*
     * 在循环的内部再创建一个循环，用来控制图形的宽度
     * 目前我们的外部的for循环执行1次，内部的就会执行5次
     * 内层循环可以来决定图形的宽度，执行几次图形的宽度就是多少
     */
    /*for(var j=0 ; j<i+1 ; j++){
     document.write("*&nbsp;&nbsp;&nbsp;");
    }*/
    for(var j=0 ; j<5-i ; j++){
     document.write("*&nbsp;&nbsp;&nbsp;");
    }
     
//   
 2、在html代码中，&amp和空格的区别

html中的转义字符&amp表示&字符，而空格表示的就是一个空格。在很多网站上编辑文字时，如果需要输入html中的一些转移字符，可能就需要用到&amp来转换。

例如：需要在页面中显示出转义字符&nbsp，而在html代码中直接这么输入，页面中显示出来的是一个空格而不是&nbsp。这就需要先将字符&通过转义字符&amp表示出来，然后在它后面输入nbsp即可。
     
     
    
    //输出一个换行
    document.write("<br />");
    
    
   }
   
   
   
  </script>
 </head>
 <body>
  
 </body>
</html>



<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 1.打印99乘法表
			 * 	 1*1=1
			 * 	 1*2=2 2*2=4
			 * 	 1*3=3 2*3=6 3*3=9
			 * 	 1*4=4 2*4=8 3*4=12 4*4=16	
			 * 						....9*9=81
			 * 
			 * 2.打印出1-100之间所有的质数
			 */
			
			//创建外层循环，用来控制乘法表的高度
			for(var i=1 ; i<=9 ; i++ ){
				//创建一个内层循环来控制图形的宽度
				for(var j=1 ; j<=i ; j++){
					document.write("<span>"+j+"*"+i+"="+i*j+"</span>");
				}
				
				//输出一个换行
				document.write("<br />");
				
			}
			
			
		</script>
		<style type="text/css">
		
			body{
				width: 2000px;
			}
			
			span{
				display: inline-block;
				width: 80px;
			}
			
		</style>
	</head>
	<body>
	</body>
</html>




<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 打印出1-100之间所有的质数
			 */
			
			//打印2-100之间所有的数
			for(var i=2 ; i<=100 ; i++){
				
				//创建一个布尔值，用来保存结果，默认i是质数
				var flag = true;
				
				//判断i是否是质数
				//获取到2-i之间的所有的数
				for(var j=2 ; j<i ; j++){
					
					//判断i是否能被j整除
					if(i%j == 0){
						//如果进入判断则证明i不是质数,修改flag值为false
						flag = false;
						
					}
					
				}
				
				//如果是质数，则打印i的值
				if(flag){
					console.log(i);
				}
				
			}
			
			
		</script>
	</head>
	<body>
	</body>
</html>




<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 打印出1-100之间所有的质数
			 */
			
			//打印2-100之间所有的数
			for(var i=2 ; i<=100 ; i++){
				
				//创建一个布尔值，用来保存结果，默认i是质数
				var flag = true;
				
				//判断i是否是质数
				//获取到2-i之间的所有的数
				for(var j=2 ; j<i ; j++){
					
					//判断i是否能被j整除
					if(i%j == 0){
						//如果进入判断则证明i不是质数,修改flag值为false
						flag = false;
						
					}
					
				}
				
				//如果是质数，则打印i的值
				if(flag){
					console.log(i);
				}
				
			}
			
			
		</script>
	</head>
	<body>
	</body>
</html>

以上是练习题

<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8">
  <title></title>
  <script type="text/javascript">
   /*
    * JS中数据类型
    *   - String 字符串
    *  	- Number 数值
    *   - Boolean 布尔值
    *   - Null 空值
    *   - Undefined 未定义
    *    - 以上这五种类型属于基本数据类型，以后我们看到的值
    *     只要不是上边的5种，全都是对象
    *   - Object 对象
    * 
    * 
    * 基本数据类型都是单一的值"hello" 123 true,
    *   值和值之间没有任何的联系。
    * 
    * 在JS中来表示一个人的信息（name gender age）：
    *   var name = "孙悟空";
    *   var gender = "男";
    *   var age = 18;
    * 如果使用基本数据类型的数据，我们所创建的变量都是独立，不能成为一个整体。
    * 
    * 对象属于一种复合的数据类型，在对象中可以保存多个不同数据类型的属性。
    * 
    * 对象的分类：
    *   1.内建对象
    *    - 由ES标准中定义的对象，在任何的ES的实现中都可以使用
    *    - 比如：Math String Number Boolean Function Object....
    * 
    *   2.宿主对象
    *    - 由JS的运行环境提供的对象，目前来讲主要指由浏览器提供的对象
    *    - 比如 BOM DOM
    * 
    *   3.自定义对象
    *    - 由开发人员自己创建的对象
    * 
    */
   
   //创建对象
   /*
    * 使用new关键字调用的函数，是构造函数constructor
    *   构造函数是专门用来创建对象的函数
    * 使用typeof检查一个对象时，会返回object
    */
   var obj = new Object();
   
   
   /*
    * 在对象中保存的值称为属性
    * 向对象添加属性
    *   语法：对象.属性名 = 属性值;
    */
   
   //向obj中添加一个name属性
   obj.name = "孙悟空";
   //向obj中添加一个gender属性
   obj.gender = "男";
   //向obj中添加一个age属性
   obj.age = 18;
   
   /*
    * 读取对象中的属性
    *   语法：对象.属性名
    * 
    * 如果读取对象中没有的属性，不会报错而是会返回undefined
    */
   
   //console.log(obj.gender);
   //console.log(obj.hello);
   
   /*
    * 修改对象的属性值
    *   语法：对象.属性名 = 新值
    */
   obj.name = "tom";
   
   /*
    * 删除对象的属性
    *   语法：delete 对象.属性名
    */
   delete obj.name;
   
   
   console.log(obj.age);
   
   
   
   
   
  </script>
 </head>
 <body>
 </body>
</html>




<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 基本数据类型
			 * 	String Number Boolean Null Undefined
			 * 
			 * 引用数据类型
			 * 	Object
			 * 
			 * JS中的变量都是保存到栈内存中的，
			 * 		基本数据类型的值直接在栈内存中存储，
			 * 		值与值之间是独立存在，修改一个变量不会影响其他的变量
			 * 
			 * 		对象是保存到堆内存中的，每创建一个新的对象，就会在堆内存中开辟出一个新的空间，
			 * 		而变量保存的是对象的内存地址（对象的引用），如果两个变量保存的是同一个对象引用，
			 * 		当一个通过一个变量修改属性时，另一个也会受到影响
			 */
			
			var a = 123;
			var b = a;
			a++;
			
			/*console.log("a = "+a);
			console.log("b = "+b);*/
			
			var obj = new Object();
			obj.name = "孙悟空";
			
			var obj2 = obj;
			
			//修改obj的name属性
			obj.name = "猪八戒";
			
			
			
			/*console.log(obj.name);
			console.log(obj2.name);*/
			
			//设置obj2为null
			obj2 = null;
			
			/*console.log(obj);
			console.log(obj2);*/
			
			var c = 10;
			var d = 10;
			//console.log(c == d);
			
			var obj3 = new Object();
			var obj4 = new Object();
			obj3.name = "沙和尚";
			obj4.name = "沙和尚";
			
			/*console.log(obj3);
			console.log(obj4);*/
			
			/*
			 * 当比较两个基本数据类型的值时，就是比较值。
			 * 而比较两个引用数据类型时，它是比较的对象的内存地址，
			 * 		如果两个对象是一摸一样的，但是地址不同，它也会返回false
			 */
			console.log(obj3 == obj4);
			
			
		</script>
	</head>
	<body>
	</body>
</html>





<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			//创建一个对象
			//var obj = new Object();
			
			/*
			 * 使用对象字面量来创建一个对象
			 */
			var obj = {};
			
			//console.log(typeof obj);
			
			obj.name = "孙悟空";
			
			//console.log(obj.name);
			
			/*
			 * 使用对象字面量，可以在创建对象时，直接指定对象中的属性
			 * 语法：{属性名:属性值,属性名:属性值....}


			 * 	对象字面量的属性名可以加引号也可以不加，建议不加,
			 * 	如果要使用一些特殊的名字，则必须加引号
			 * 


			 * 属性名和属性值是一组一组的名值对结构，
			 * 	名和值之间使用:连接，多个名值对之间使用,隔开


			 * 	如果一个属性之后没有其他的属性了，就不要写,



			 
			 */
			var obj2 = {
				
				name:"猪八戒",
				age:13,
				gender:"男",
				test:{name:"沙僧"}
				
			};
			
			console.log(obj2.test);
			
		</script>
	</head>
	<body>
	</body>
</html>



<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 函数 function
			 * 	- 函数也是一个对象
			 * 	- 函数中可以封装一些功能（代码），在需要时可以执行这些功能（代码）
			 * 	- 函数中可以保存一些代码在需要的时候调用
			 * 	- 使用typeof检查一个函数对象时，会返回function
			 */
			
			//我们在实际开发中很少使用构造函数来创建一个函数对象
			//创建一个函数对象
			//可以将要封装的代码以字符串的形式传递给构造函数
			//var fun = new Function("console.log('Hello 这是我的第一个函数');");
			
			//封装到函数中的代码不会立即执行
			//函数中的代码会在函数调用的时候执行
			//调用函数 语法：函数对象()
			//当调用函数时，函数中封装的代码会按照顺序执行
			//fun();
			
			/*
			 * 使用 函数声明 来创建一个函数
			 * 	语法：
			 * 		function 函数名([形参1,形参2...形参N]){
			 * 			语句...
			 * 		}
			 */
			
			function fun2(){
				console.log("这是我的第二个函数~~~");
				alert("哈哈哈哈哈");
				document.write("~~~~(>_<)~~~~");
			}
			
			//console.log(fun2);
			//调用fun2
			//fun2();
			
			/*
			 * 使用 函数表达式 来创建一个函数
			 * var 函数名  = function([形参1,形参2...形参N]){
			 * 	 语句....
			 *  }
			 */
			
			var fun3 = function(){
				console.log("我是匿名函数中封装的代码");
			};
			
			
			fun3();
			
		</script>
	</head>
	<body>
	</body>
</html>




<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
		<script type="text/javascript">
			
			/*
			 * 定义一个用来求两个数和的函数
			 * 	可以在函数的()中来指定一个或多个形参（形式参数）
			 * 	多个形参之间使用,隔开，声明形参就相当于在函数内部声明了对应的变量
			 * 	但是并不赋值
			 */
			function sum(a,b){
				console.log("a = "+a);
				console.log("b = "+b);
				console.log(a+b);
			}
			
			/*
			 * 在调用函数时，可以在()中指定实参（实际参数）
			 * 	实参将会赋值给函数中对应的形参
			 */
			/*sum(1,2);
			sum(123,456);*/
			
			/*
			 * 调用函数时解析器不会检查实参的类型,
			 * 	所以要注意，是否有可能会接收到非法的参数，如果有可能则需要对参数进行类型的检查
			 * 函数的实参可以是任意的数据类型
			 */
			//sum(123,"hello");
			//sum(true , false);
			
			/*
			 * 调用函数时，解析器也不会检查实参的数量
			 * 	多余实参不会被赋值
			 * 如果实参的数量少于形参的数量，则没有对应实参的形参将是undefined
			 * 
			 */
			//sum(123,456,"hello",true,null);
			sum(123);
			
		</script>
	</head>
	<body>
	</body>
</html>