JS基础

变量

//定义变量
var a,b                 //定义变量a 变量 b
​
//变量赋值
var a
a = 100
var b = 200             //a赋值为100  b赋值为200
​
//输出变量
var a = 100
console.log(a)          //输出变量a的值 为100

数据类型

//数字类型（number）  不区分整数和浮点数
var a = 100             //定义变量a的值为数字100
var b = 200             //定义变量b的值为数字200
​
//字符串类型（string） 以引号包裹的内容，就是字符串类型
var a = '100'           //定义变量a的值为字符串100
var b = 'abc'           //定义变量b的值为字符串'abc'
​
//布尔类型（boolean） 更多用在判断上，一个值为true，一个值为false
var a = true            //定义变量a的值为真true
var b = false           //定义变量b的值为假false
​
//undefined（未定义）    如果变量没有赋值默认undefined ，表明未定义
var a
console.log(a)          //此时，变量a的值为undefined
​
//null（空）
var a = null            //定义变量a的值为空

检测数据类型

var a = 100
console.log(typeof(a))      //检测变量a的数据类型 为number
var b = 'abc'
console.log(typeof(b))      //检测变量b的数据类型 为string
var c = true
console.log(typeof(c))      //检测变量c的数据类型 为Boolean
var d = null
console.log(typeof(d))      //检测变量d的数据类型为object
var e 
var f = undefined
console.log(typeof(e))      
console.log(typeof(f))      //检测变量 e和 f的数据类型为undefined

数据类型转换

转换数字类型

//number(数据)
    //可以用任何数据类型，转换成数字类型，其他类型的字符串会转换成 NaN
    //null 或者 空白值 会转换成 0；
    //true 会转换成 1，false会转换成 0；
​
                //数据的类型         //数据的值
console.log(typeof(Number('100')),Number('100'))
console.log(typeof(Number(null)),Number(null))
console.log(typeof(Number(true)),Number(true))
console.log(typeof(Number(false)),Number(false))
​
​
//parseInt(数据)
    //转换为number类型，并且值为整数（直接忽略小数点以后的值，并不是四舍五入）
    //如果数据是纯数字的字符串，或者以数字开头的字符串，那么会转换成数字，否则转换成NaN
​
                    //数据的类型         //数据的值
console.log(typeof(parseInt('100')),parseInt('100'))
console.log(typeof(parseInt('100abc')),parseInt('100abc'))
​
​
//parseFloat(数据)
    //转换结果与parseInt类似，但是在转换小数时，会保留小数点以后的数字
​
​
                    //数据的类型         //数据的值
console.log(typeof(parseFloat('100')),parseFloat('100')) 
console.log(typeof(parseFloat('100ab')),parseFloat('100ab'))
console.log(typeof(parseFloat(100.123)),parseFloat(100.123))
​
​
//在实际开发中，常用 “数据 - 0”的方式，转换成数字类型
console.log(typeof('100' - 0),'100' - 0)

转换字符串类型

//string(变量)
    //所有类型转换成字符串
var a = 100
var b = string(a)           //将变量a的值转换成字符串类型，并且赋值给b
​
//变量.tostring()
var a = 100
a.tostring()                //将变量a的值转换成字符串类型

转换布尔类型

//Boolean(数据)
    //在js中，之后''（空字符串，有空格也不行） 0 ，null，undefined，NaN，这些是false
    //除了上述的 ，其余全部为true
var a = 100
Boolean(a)                  //将变量a的值 转换为布尔类型，并且值为true

数据类型区别

//数据类型分为两种
    //1.基本数据类型（简单数据类型）
    //2.引用数据类型（复杂数据类型）

存储

//1.存储
    //变量的数据存储的地方是内存 内存分为两个： 栈内存 堆内存
    //1.1基础数据类型：存储的是值，存储在栈内存中 比如：string number undefined null Boolean
    //1.2引用数据类型：存储的是地址，将数据本体存放在堆内存中，然后将指向该内存的地址，存放在object名、array名、function名中，这些名默认存放 在栈内存中 比如：object array function 
var num = 100
var str = 'abc'                     //存储在栈内存中
var obj = {
    a:1,
    b:2,
}
var arr = {1,2,3,4}                 //数据本体存在堆内存中，地址存名中，名存在栈内存中

赋值

//2.赋值
	//2.1基础数据类型：赋值以后，两个变量没有任何关系，相当于将自己某一个东西，复制一份出去
var num1 = 100
var num2 = num1						//num2 === num1 === 100
num2 = 666
console.log(num1)
console.log(num2)					//num1为 100  num2为 666
	//2.2引用数据类型：变量内部存储的是指向堆内存的地址，赋值时，其实是将这个地址给到另一个变量，那么相当于这两个变量存储的是同一个钥匙，所以操作其中一个变量时，会影响另一个变量
var obj1 = {
    name:'abc',
    age: 18,
}
var obj2 = obj1				//这一步相当于将变量 obj1内部存储的”钥匙“ ，给到了变量obj2 
console.log(obj2)		

比较

//3.比较
	//3.1基本数据类型：值的比较
var num1 = 100
var num2 = 100
console.log(num1 === num2)			//true
	//3.2引用数据类型：比较时，比较的是 地址
var obj1 = {
    name:'abc',
    age: 18
}
console.log(obj1 === obj2)  		//false
var arr1 = [1,2,3]
var arr2 = arr1
console.log(arr1 === arr2)  		//true

传参

//4.传参
	//4.1基本数据类型：将值拷贝一份传递给形参，在函数内修改不会影响外界
function fn(num){
    num = 'abc'
}
var str = 'aaa'
fn(str)
console.log(str)					//'aaa'
	//4.2引用数据类型：将存储地址赋值给形参，在函数内修改会影响外界
function fn(o){
    o.name = 'qwer'
}
var obj = {
    name: 'abc'
}
fn(obj)
console.log(obj.name) 				//'qwer'

!案例

//案例
var obj = {
  	name: 'jack'
}								//创建一个便俩把那个叫做obj，数据本体{name:jack}
 function fn(){					// 定义一个 fn函数， 没有调用 所以直接向下走
   	obj.name = 'rose'
   	obj = {}
    obj.name = 'jerry'
  	console.log(obj.name)			//输出的值为jerry
}
fn()
console.log(obj.name)				//输出的值为jerry（全局变量）