JavaScript基础01 - 概述、HTML中嵌入JavaScript代码的三种方式、ECMAScript第一部分
JavaScript基础01
- 000-JavaScript概述
- 001-HTML中嵌入JavaScript代码的第一种方式
- 002-HTML中嵌入JavaScript代码的第二种方式
- 003-HTML中嵌入JavaScript代码的第三种方式
- 004-关于js中的变量
- 005-JS函数初步
- 006-JS函数初步2
- 007-JS的局部变量和全局变量
- 008-JS的数据类型
- 009-undefined类型
- 010-Number类型
- 011-Boolean类型
- 012-String类型
- 013-Object类型
- 014-null NaN undefined
000-JavaScript概述
- JavaScript是运行在浏览器上的脚本语言。简称JS。
- JavaScript是网景公司（NetScape）的 布兰登艾奇（JavaScript之父）开发的，最初叫做LiveScript。
- LiveScript的出现让浏览器更加的生动了，不再是单纯的静态页面了。页面更具有交互性。
- 在历史的某个阶段，SUN公司和网景公司他们之间有合作关系，SUN公司把LiveScript的名字修改为JavaScript。
- JavaScript这个名字中虽然带有"Java"但是和Java没有任何关系，只是语法上优点类似。他们运行的位置不同，Java运行在JVM当中，JavaScript运行在浏览器的内存当中。
- JavaScript程序不需要我们程序员手动编译，编写完源代码之后，浏览器直接打开解释执行。
- JavaScript的”目标程序“以普通文本形式保存，这种语言叫做”脚本语言“。
- Java的目标程序以.class形式存在，不能使用文本编辑器打开，不是脚本语言。
- 以后大家会学习一个叫做JSP的技术，JSP和JS有啥区别？
- JSP ： JavaServer Pages（隶属于Java语言的，运行在JVM当中。）
- JS ： JavaScript（运行在浏览器上。）
001-HTML中嵌入JavaScript代码的第一种方式
doctype html>
<html>
<head>
<title>HTML中嵌入JavaScript代码的第一种方式title>
head>
<body>
<input type="button" value="开始" onclick="window.alert('hello js!')"/>
<br>
<input type="button" value="开始" onclick='window.alert("hello js!")'/>
<br>
<input type="button" value="开始" onclick="window.alert('hello js1!')
window.alert('hello js2!')
window.alert('hello js3!')"/>
<br>
<input type="button" value="开始" onclick="alert('hello zhangsan!');alert('hello lisi!');alert('hello wangwu!')"/>
body>
html>
002-HTML中嵌入JavaScript代码的第二种方式
<script type="text/javascript">
// alert函数会阻塞整个HTML页面的加载，直到用户点击确定按钮。
window.alert("first......!");
script>
doctype html>
<html>
<head>
<title>HTML中嵌入JavaScript代码的第二种方式title>
<style type="text/css">
/*
css代码
*/
style>
<script type="text/javascript">
window.alert("head......!");
script>
head>
<body>
<script type="text/javascript">
/*
暴露在脚本块当中的程序，在页面打开的时候执行，
并且遵守自上而下的顺序依次逐行执行。（这个代
码的执行不需要事件）
*/
window.alert("Hello World!"); // alert函数会阻塞整个HTML页面的加载。
// JS代码的注释，这是单行注释。
/*
JS代码的多行注释
*/
window.alert("Hello JavaScript!");
script>
<input type="button" value="我是一个按钮"/>
body>
html>
<script type="text/javascript">
window.alert("last......!");
script>
003-HTML中嵌入JavaScript代码的第三种方式
doctype html>
<html>
<head>
<title>HTML中嵌入JavaScript代码的第三种方式：引入外部独立的js文件title>
head>
<body>
<script type="text/javascript" src="file/1.js">script>
<script type="text/javascript" src="file/1.js">
// 这里写的代码不会执行
//window.alert("Test!");
script>
<script type="text/javascript">
alert("hello jack!");
script>
body>
html>
004-关于js中的变量
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>关于js中的变量title>
head>
<body>
<script type="text/javascript">
// 在JS当中，当一个变量没有手动赋值的时候，系统默认赋值是undefined
var i;
// undefined在JS当中是一个具体存在值。
alert("i=" + i);
alert(undefined);
var k = undefined;
alert("k=" +k);
//一个变量没有声明/定义，直接访问会报错。
//alert(age);//语法错误：age is not define
var a,b,c = 200;
alert("a=" + a);
alert("b=" + b);
alert("c=" + c);
a = false;
alert(a);
a = "abc";
alert(a);
a = 1.2;
alert(a);
script>
body>
html>
005-JS函数初步
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JS函数初步title>
head>
<body>
<script type="text/javascript">
/*
1、JS中的函数
等同于java语言中的方法，函数也是一段可以被重复利用的代码片段。
函数一般都是可以完成某个特定功能的。
2、回顾java的方法？
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
例如：
public static boolean login(String username, String password){
return true;
}
boolean loginSuccess = login("lisi","123");
3、JS中的变量是一种弱类型的，那么函数应该怎么定义呢？
语法格式：
第一种方式：
function 函数名(形式参数列表){
函数体;
}
第二种方式：
函数名 = function(形式参数列表){
函数体;
}
JS中的函数不需要指定返回值类型，返回什么类型都行。
* */
function sum(a,b){
// a,b都是局部变量，他们都是形参（a和b都是变量名，变量名随意。）
alert(a + b);
}
// 函数必须调用才能执行。
sum(10,20)
// 定义函数sayHello
sayHello = function(username){
alert("hello" + username);
}
sayHello("World!");
script>
<input type="button" value="hello" onclick="sayHello('World!')"/>
<input type="button" value="计算10和20的和" onclick="sum(10,20)"/>
body>
html>
006-JS函数初步2
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JS函数初步2title>
head>
<body>
<script type="text/javascript">
/*
java中的方法有重载机制，JS中的函数能重载吗？
JS当中的函数在调用的时候，参数的类型没有限制，并且参数的个数也没有限制，JS就是这么随意。（弱类型）
重载的含义：
方法名或者函数名一样，形参不同（个数、类型、顺序）
* */
function sum(a,b) {
return a + b;
}
// 调用函数sum
var retValue = sum(1,2);
alert(retValue);
var retValue2 = sum("jack");// "jack"赋值给a变量了，b变量没有赋值，系统给默认赋值undefined
alert(retValue2); // jackundefined
var retValue3 = sum();
alert(retValue3); // NaN,NaN是一个具体存在的值，该值表示不是数字，Not a number！
var retValue4 = sum(1,2,3);
alert("结果=" + retValue4);// 结果=3
function test1(username) {
alert("test1");
}
function test1() {
alert("test1 test1");
}
// 调用的是第二个函数test1()
// 在JS当中，函数的名字不能重名，当函数重名的时候，后声明的函数会将之前声明的函数覆盖掉。
test1("lisi");
script>
body>
html>
007-JS的局部变量和全局变量
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JS的局部变量和全局变量title>
head>
<body>
<script type="text/javascript">
/*
全局变量：
在函数体之外声明的变量属于全局变量，全局变量的生命周期是：
浏览器打开时声明，浏览器关闭时销毁，尽量少用。因为全局变量
会一直在浏览器的内存当中，耗费内存空间。
局部变量：
在函数体当中声明的变量，包括一个函数的形参都属于局部变量。
局部变量的生命周期是：函数开始时局部变量的内存空间开辟，
函数执行结束之后，局部变量的内存空间释放。
局部变量生命周期较短。
* */
// 全局变量
var i = 100;
function access() {
// 访问的是全局变量
alert("i=" + i);
}
access();
// 全局变量
var username = "jack";
function accessUsername() {
// 局部变量
var username = "lisi";
// 就近原则：访问局部变量
alert("username=" + username);
}
// 调用函数
accessUsername();
// 访问的是全局变量
alert("username=" + username);
function accessAge() {
var age = 20;
alert("age=" + age);
}
accessAge();
//alert("age=" + age); // age is not defined
// 以下语法是很奇怪的。
function myfun(){
// 当一个变量声明的时候没有使用var关键字，那么不管这个变量是在哪里声明的，都是全局变量。
myname = "fbi";
}
// 调用函数
myfun();
alert("myname=" + myname);
script>
body>
html>
008-JS的数据类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JS的数据类型title>
head>
<body>
<script type="text/javascript">
/**
1、虽然JS中的变量在声明的时候不需要指定数据类型，但是在赋值的时候，每一个数据还是有类型的，所以
这里也需要学习一下JS包括哪些数据类型？
JS中数据类型有：原始类型、引用类型、
原始类型：Undefined、Number、String、Boolean、Null
引用类型：Object以及Object的子类。
2、ES规范（ECMAScript），在ES6之后，又基于以上的6种类型之外添加了
一种新的类型，Symbol。
3、JS中有一个运算符叫做typeof，这个运算符可以在程序的运行阶段动态的获取
变量的数据类型。
typeof运算符的语法格式：
typeof 变量名
typeof运算符的运算结果是以下6个字符串之一：注意字符串都是全部小写。
"undefined"
"number"
"string"
"boolean"
"object"
"function"
4、在js当中比较字符串是否相等使用"=="完成。没有equals。
*/
// 求和，要求a变量和b变量将来的数据类型必须是数字，不能是其他类型。
// 因为以下定义的这个sum函数是为了完成两个数字的求和。
function sum(a, b){
if(typeof a == "number" && typeof b == "number"){
return a + b;
}
alert(a + "," + b + "必须都为数字");
}
// 别人去调用以上你写的sum函数。
var retValue = sum(false,"abc");
alert(retValue); // undefined
var retValue2 = sum(1,2);
alert(retValue2);
alert("-------------");
var i;
alert(typeof i); // "undefined"
var k = 10;
alert(typeof k); // "number"
var f = "abc";
alert(typeof f); // "string"
var d = null;
// null是Null类型，但是typeof运算符的结果是"object"
alert(typeof d); // "object"
var flag = false;
alert(typeof flag); // "boolean"
var obj = new Object();
alert(typeof obj); // "object"
function sayHello(){
}
alert(typeof sayHello); // "function"
script>
body>
html>
009-undefined类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>undefined类型title>
head>
<body>
<script type="text/javascript">
/*
Undefined类型只有一个值，这个值就是undefined
当一个变量没有手动赋值，系统默认赋值undefined
或者也可以给一个变量手动赋值undefined
*/
var i; // Undefined
var k = undefined; // Undefined
alert(i == k); // true
var y = "undefined"; // String
alert(k == y); // false
script>
body>
html>
010-Number类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Number类型title>
head>
<body>
<script type="text/javascript">
/*
1、Number类型包括哪些值？
-1 0 1 2 2.3 3.14 100 ... NaN Infinity
整数、小数、正数、复数、不是数字、无穷大都属于Number类型。
2、isNaN():结果是true表示不是一个数字，结果是false表示是一个数字。
3、pareseInt()函数
4、parseFloat()函数
5、Math.ceil()函数（Math是数学类，数学类当中有一个函数叫做ceil()，作用是向上取整。）
*/
var v1 = 1;
var v2 = 3.14;
var v3 = -100;
var v4 = NaN;
var v5 = Infinity;
alert(typeof v1);
alert(typeof v2);
alert(typeof v3);
alert(typeof v4);
alert(typeof v5);
// 关于NaN（表示Not a Number，不是一个数字，但属于Number类型）
// 什么情况下结果是一个NaN呢？
// 运算结果本来应该是一个数字，最后算完不是一个数字的时候，结果是NuN。
var a = 100;
var b = "中国人";
// 除号显然最后结果是一个数值，但是运算的过程中导致最后不是一个数字，那么最后的结果是NaN。
alert(a / b);
var e = "abc";
var f = 10;
alert(e + f); // "abc10"
// Infinity（当除数为0的时候，结果为无穷大）
alert(10 / 0);
// 思考：在JS中10 / 3 = ？
alert(10 / 3); // 3.3333333333333335
// 关于isNaN的函数？
// 用法：isNaN(数据)，结果是true表示不是一个数字，结果是false表示是一个数字。
// isNaN， is Not a Number
function sum(a,b){
if(isNaN(a) || isNaN(b)){
alert("参与运算的必须是数字！");
return;
}
return a + b;
}
sum(100,"abc");
sum(100,200);
// parseInt()：可以将字符串自动转换成数字，并且取整数位。
alert(parseInt("3.999999")); // 3
alert(parseInt(3.999999)); // 3
// parseFloat();可以将字符串自动转换成数字。
alert(parseInt("3.14") + 1); // 4.14
alert(parseFloat("3.2") + 1); // 4.2
// Math.ceil()
alert(Math.ceil("2.1")); // 3
script>
body>
html>
011-Boolean类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Boolean类型title>
head>
<body>
<script type="text/javascript">
/*
1、JS中的布尔类型永远都是只有两个值：true和false。
2、在Boolean类型当中有一个函数叫做：Boolean()。
语法格式：
Boolean(数据)
Boolean()函数的作用是将非布尔类型转换成布尔类型。
*/
var username = "jack";
if(username){
alert("欢迎你" + username);
}else{
alert("用户名不能为空!");
}
if(Boolean(username)){
alert("欢迎你" + username);
}else{
alert("用户名不能为空!");
}
// 规律：“有”就转换成true，“没有”就转换成false
alert(Boolean(1)); // true
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("abc")); // true
alert(Boolean(null)); // false
alert(Boolean(NaN)); // false
alert(Boolean(undefined)); // false
alert(Boolean(Infinity)); // true
// Null这种类型只有一个值：null
alert(typeof null); // "object"
script>
body>
html>
012-String类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>String类型title>
head>
<body>
<script type="text/javascript">
/*
String类型：
1、在JS当中字符串可以使用单引号，也可以使用双引号。
var s1 = 'abcdef';
var s2 = "test";
2、在JS当中，怎么创建字符串对象呢？
两种方式：
第一种：var s = "abc";
第二种：使用JS内置的支持类String：
var s = new String("abc");
需要注意的是，String是一个内置的类，可以直接使用，String父类是Object。
3、无论是小string还是大String，他们的属性都是通用的。
4、关于String类型的常用属性和函数？
常用属性：
length 获取字符串长度
常用方法：
indexOf 获取指定字符串在当前字符串中第一次出现的索引
lastIndexOf 获取指定字符串在当前字符串中最后一次出现的索引
replace 替换
substr 截取字符串
substring 截取字符串
toLowerCase 转换小写
toUpperCase 转换大写
split 拆分字符串
*/
// 小string（属于原始类型String）
var x = "abc";
alert(typeof x); // "string"
// 大String（属于Object类型）
var y = new String("abc");
alert(typeof y); // "object"
alert(x.length); // 3
alert(y.length); // 3
alert("http://www.baidu.com".indexOf("http")); // 0
alert("http://www.baidu.com".indexOf("https")); // -1
// 判断一个字符串中是否包含某个字符串？
alert("http://www.baidu.com".indexOf("https") >= 0 ? "包含" : "不包含"); // 不包含
// replace
/* name=value%name=value&name=value
只替换了一个*/
alert("name=value&name=value&name=value".replace("&","%"));
// 考点：经常问，substr和substring的区别？
// substr(startIndex,length)
alert("abcdefxyz".substr(2,4)); // cdef
// substring(startIndex,endIndex) 注意不包含endIndex
alert("abcdefxyz".substring(2,4)); // cd
script>
body>
html>
013-Object类型
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Object类型title>
head>
<body>
<script type="text/javascript">
/*
Object类型：
1、Object类型是所有类型的超类，自定义的任何类型，默认继承Object。
2、Object类型包括哪些属性？
prototype属性（常用的），作用是给类动态的扩展属性和函数。
constructor属性
3、Object类包括哪些方法？
toString()
valueOf()
toLocalString()
4、在JS当中定义的类默认继承Object，会继承Object类中所有的属性以及函数。
5、在JS当中怎么定义类？怎么new对象？
定义类的语法：
第一种方式：
function 类名(形参){
}
第二种方式：
类名 = function(形参){
}
创建对象的语法：
new 构造方法名(形参) // 构造方法名和类名一致。
*/
function sayHello(){
}
// 把sayHello当作一个普通的函数来调用
sayHello();
// 把sayHello当作一个类来创建对象
var obj = new sayHello(); // obj是一个引用，保存内存地址指向堆中的对象。
// 定义一个学生类
function Student(){
alert("Student....");
}
// 当作普通函数来调用
Student();
// 当作类来常见对象
var stu = new Student();
alert(stu); // [object Object]
// JS中类的定义，同时又是一个构造函数的定义
// 在JS中类的定义和构造函数的定义是放在一起来完成的。
function User(a,b,c) { // a,b,c是形参，属于局部变量
// 声明属性（this表示当前对象）
// User类中有三个属性：sno/sname/sage
this.sno = a;
this.sname = b;
this.sage = c;
}
var u1 = new User(111,"zhangsan",30);
// 访问对象的属性
alert(u1.sno);
alert(u1.sname);
alert(u1.sage);
var u2 = new User(222,"jack",30);
alert(u2.sno);
alert(u2.sname);
alert(u2.sage);
// 访问一个对象的属性，还可以使用这种语法。
alert(u2["sno"]);
alert(u2["sname"]);
alert(u2["sage"]);
// 定义类的另一种语法
Emp = function (ename,sal) {
this.ename = ename;
this.sal = sal;
}
var e = new Emp("lisi",2000);
alert(e["ename"] + ", " + e.sal);
Product = function(pno,pname,price){
// 属性
this.pno = pno;
this.pname = pname;
this.price = price;
// 函数
this.getPrice = function(){
return this.price;
}
}
var pro = new Product(111,"西瓜",4.0);
var pri = pro.getPrice();
alert(pri); // 4.0
// 可以同过prototype这个属性来给类动态扩展属性以及函数
Product.prototype.getPname = function () {
return this.pname;
}
// 调用后期扩展的Pname函数
var pname = pro.getPname();
alert(pname); // 西瓜
// 给String扩展一个函数
String.prototype.suiyi = function(){
alert("这是给String类型扩展的一个函数，叫做suiyi");
}
"abc".suiyi();
script>
body>
html>
014-null NaN undefined
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>null NaN undefinedtitle>
head>
<body>
<script type="text/javascript">
// null NaN undefined数据类型不一致
alert(typeof null); // "object"
alert(typeof NaN); // "number"
alert(typeof undefined); // "undefined"
// null和undefined可以等同
alert(null == NaN); // false
alert(null == undefined); // true
alert(NaN == undefined); // false
// 在JS当中有两个比较特殊的运算符
// ==（等同运算符，只判断值是否相等）
// ===（全等运算符，既判断值是否相等，又判断数据类型是否相等）
alert(null === NaN); // false
alert(null === undefined); // false
alert(NaN === undefined); // false
alert(1 == true); // true，1等同于真，boolean函数自动转换1为true
alert(1 === true); // false，数据类型不同
script>
body>
html>