数组与对象

数组与对象总结

JavaScript

JS数组

//典型的数组
var array = [1,2,3]

//数组的访问
array[0];//获取第0个位置的值
//结果：1

array[0]=4;//给第0个元素赋值成4
//结果：[4,2,3]

array.push(4);//在数组最后插入一个元素4，并返回新长度
//结果：[1,2,3,4]

array.unshift(4);// 将新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
//结果：[4,1,2,3]

array.pop();//移除最后一个元素，并返回该元素值
//结果：[1,2]

array.shift(); //移除最前一个元素并返回该元素值,数组中元素自动前移
//结果：[2,3]

array.splice(1, 2);//在位置1开始，删除2个元素
//结果:[1]

array.splice(1,0,777);//在位置1处添加一个元素，原元素后移，返回""
//结果：[1,777,2,3]

array.splice(1,2,777);//在位置1处添加一个新元素，并删除2个元素
//结果：[1,777]

[es6更多方法](https://www.cnblogs.com/sqh17/p/8529401.html)
[更多操作](https://www.cnblogs.com/qiantuwuliang/archive/2011/01/08/1930499.html)

//数组的遍历（for...of）推荐 🌟
for(const value of array){
	console.log(value)
}
//1
//2
//3

//数组的遍历（传统方法）
for(var i=0;i<array.length;i++){
	cosole.log(i,array[i])
}
//0,1
//1,2
//2,3

//数组的遍历（forEach）
array.forEach(function(value,index){
	console.log(index,value)
})
//0,1
//1,2
//2,3

//数组的遍历（for..in）
for(var i in array){
	cosole.log(i,array[i])
}
//0,1
//1,2
//2,3

JS对象

//典型的对象
var obj = {"a":1,"b":2,"c":3}

//对象获取值
obj.a;//获取名称a的值
//结果：1

//对象的遍历（ES6一共有5种）
##（1）for...in
//for...in循环遍历对象自身的和继承的可枚举属性（不含Symbol属性）。
for(var key in obj){
	//key:对象键值名，obj[key]:具体值
	console.log(key,obj[key])
}

//a,1
//b,2
//c,3

- 2）Object.keys(obj)
//Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含Symbol属性）。
console.log(Object.keys(obj));
//["a", "b", "c"]
console.log(Object.values(obj));
// [1, 2, 3]

-（3）Object.getOwnPropertyNames(obj)
//Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含Symbol属性，但是包括不可枚举属性）。
console.log(Object.getOwnPropertyNames(obj));
//["a", "b", "c"]

-（4）Object.getOwnPropertySymbols(obj)
//Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有Symbol属性。
console.log(Object.getOwnPropertySymbols(obj));
//[]

-（5）Reflect.ownKeys(obj)
//Reflect.ownKeys返回一个数组，包含对象自身的所有属性，不管是属性名是Symbol或字符串，也不管是否可枚举。
console.log(Object.ownKeys(obj))
//Uncaught TypeError: Object.ownKeys is not a function

//解构赋值
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }
//扩展运算符
let z = { a: 3, b: 4 };
let n = { ...z,c:777 };
n // { a: 3, b: 4 ,c:777}
[更多es6方法](https://www.runoob.com/w3cnote/es6-object.html)
[更多es6方法](https://www.cnblogs.com/woodk/p/6564055.html)

vue

//vue的写法
const HelloVueApp = { //声明一个对象
  data() {//一个方法data()
    return {//方法返回值，返回对象
      message: 'Hello Vue!!'
    }
  }
}
//这样写的好处，外部使用点语法调用
HelloVueApp.data().message
//结果：Hello Vue!

JSON转换

//典型的对象JSON
var str = '{"name":"小飞","age":38}';

//将字符串转化json对象：
//1.必须是标准json格式，双引号 
var json = JSON.parse(str);

//2. 可以转换非标准格式
var json = eval("(" + str + ")");//举例：eval(`(${变量})`)

//3. 函数方式转换，可以使用非标准json
var json = (new Function("return " + str))();

//json转对象
JSON.stringify(str);

Js字符串操作

var schoolhref = 'abcd-fdef.fff';
var schoolhrefs = schoolhref.substring(schoolhref.indexOf('-') + 1); //截取-后面的内容
var id = schoolhrefs.substring(0, schoolhrefs.indexOf('.')); //截全.前面的内容

str.length - 1

获取字符串中间内容
例：获取c和f中间内容
String str = "abcdefg";
String str2 = str.substring(str.indexOf("c")+ 1,str.indexOf("f"));

/*
 string 字符串;
 str 指定字符;
 split(),用于把一个字符串分割成字符串数组;
 split(str)[0],读取数组中索引为0的值（第一个值）,所有数组索引默认从0开始;
 */
//split分割成数组，然后获取
var str_before = string.split(str)[0];
  var str_after = string.split(str)[1];
  alert('前：'+str_before+' - 后：'+str_after);

PHP

PHP数组

<?php 
  $arr=['a'=>123,'b'=>456]; //数组初始化方法1
  $arr=array("a"=>123,"b"=>456);//初始化方式2
  echo $arr['a']; //数组引用,值123
  print_r($arr); //查看数组
  //for遍历，只能用于遍历，纯索引数组
  for($i=0;$i<count($arr);$i++){
     echo $arr[$i];
  }
  //foreach遍历，可以遍历所有数组
  foreach ($arr as $key => $value) {
    echo "{$key}:{$value},";
  }
  //更多数组的遍历：https://www.jb51.net/article/156328.htm

PHP对象

<?php 
  class A{ 
    public $a=123; 
    public $b=456; 
  } 
  $obj=new A();
  echo $obj->a; //对象引用
  print_r($obj); //查看对象
  
  //foreach遍历
  foreach($obj as $key => $value) {
    print "$key => $value\n";
  }
  //对象中方法遍历和使用：https://www.php.net/manual/zh/language.oop5.iterations.php

JAVA

JAVA对象，类

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 更多概念：https://www.runoob.com/java/java-object-classes.html
• java中的对象使用get/set来提供对外访问

JAVA数组

• 数组的长度固定，集合长度可变换
• 数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
• 数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

int[] array ={1,2,3};//定义一个数组方法1

int[] array = new int[3];//定义一个数组方法2
array[0]=1;
array[1]=2;
array[2]=3;

//for遍历
for (int i = 0; i < array.length; i++) {
	System.out.print(array[i]);
}

//foreach遍历
for (int element: array) {
    System.out.println(element);
  }
//转换成stirng直接输出
System.out.println(Arrays.toString(array));
//更多arrays操作：https://www.cnblogs.com/wei-jing/p/10540192.html

JAVA集合

• List，继承Collection，可重复、有序的对象

• Set，继承Collection，不可重复、无序的对象

• Map，键值对，提供key到value的映射。key无序、唯一；value无序，可重复

• 线程安全的效率都比较低，Vector，已被淘汰，可使用ArrayList替代。Hashtable，已被淘汰，可使用HashMap替代，如果是高并发的线程安全的实现，推荐使用ConcurrentHashMap。
• 常用集合 List / ArrayList，Map / HashMap

List：

//定义一个arraylist
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");

//传统遍历
for(int i=0;i<list.size();i++){
	System.out.println(list.get(i));
}

//foreach遍历
for (String str : list) {
   System.out.println(str);
}

//Iterator遍历
Iterator<String> ite=list.iterator();
while(ite.hasNext())//判断下一个元素之后有值
{
    System.out.println(ite.next());
}

Map:

//定义一个map
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");

//map内部是键值队{1=value1, 2=value2, 3=value3},但凡这种样式，包括js都不能使用传统循环取值

//foreach遍历1【取不到key】
for (String v : map.values()) {
    System.out.println(v);
 }
 
//foreach遍历2【keyset方法可以获取key】
for (String key : map.keySet()) {
  System.out.println(key + map.get(key));
 }
 
//大容量map遍历
for (Map.Entry<String, String> entry : map.entrySet()) {
 	System.out.println(entry.getKey() +entry.getValue());
}

//Iterator遍历
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
 Map.Entry<String, String> entry = it.next();
 System.out.println(entry.getKey() + entry.getValue());
}