精华内容
下载资源
问答
  • jQuery中查找数组索引inArray ...注意了:在ECMAScript5已经有数据indexOf方法支持了,但是jQuery保持了版本向下兼容,所以封装了一个inArray方法 jQuery.inArray()函数用于在数组中搜索指定...

    jQuery中查找数组中的索引inArray

    在PHP有in_array()判断某个元素是否存在数组中,JavaScript却没有,但是jQuery封装了inArray()函数判断元素是否存在数组中。注意了:在ECMAScript5已经有数据的indexOf方法支持了,但是jQuery保持了版本向下兼容,所以封装了一个inArray方法

    jQuery.inArray()函数用于在数组中搜索指定的值,并返回其索引值。如果数组中不存在该值,则返回 -1。

    语法:

    jQuery.inArray( value, array ,[ fromIndex ] )

    用法非常简单,传递一个检测的目标值,然后传递原始的数组,可以通过fromIndex规定查找的起始值,默认数组是0开始

    例如:在数组中查找值是5的索引

    $.inArray(5,[1,2,3,4,5,6,7]) //返回对应的索引:4

    注意:

    如果要判断数组中是否存在指定值,你需要通过该函数的返回值不等于(或大于)-1来进行判断

    jQuery中去除空格神器trim方法

    页面中,通过input可以获取用户的输入值,例如常见的登录信息的提交处理。用户的输入不一定是标准的,输入一段密码:’ 1123456 “,注意了: 密码的前后会留空,这可能是用户的无心的行为,但是密码确实又没错,针对这样的行为,开发者应该要判断输入值的前后是否有空白符、换行符、制表符这样明显的无意义的输入值。

    jQuery.trim()函数用于去除字符串两端的空白字符

    这个函数很简单,没有多余的参数用法

    需要注意:

    • 移除字符串开始和结尾处的所有换行符,空格(包括连续的空格)和制表符(tab)
    • 如果这些空白字符在字符串中间时,它们将被保留,不会被移除
    展开全文
  • 数组方法: forEach方法的第一个参数是一个函数,函数第一个参数是元素,第二个参数才是索引号,与变量名没关系,顺序是固定 不能写continue、break,return也不能终止循环,想要终止循环,可以用some方法 ...

    数组方法:

    • forEach方法的第一个参数是一个函数,函数的第一个参数是元素,第二个参数才是索引号,与变量名没关系,顺序是固定的
      • 不能写continue、break,return也不能终止循环,想要终止循环,可以用some方法
    • filter方法,是用来过滤数组元素
      • 接收一个函数作为参数,这个函数的第一个形参是元素,第二个形参是索引号
      • 内部会有循环机制,每次循环都会调用函数,如果函数返回true,则保留当前循环元素,如果返回false,则剔除当前循环元素
      • 会返回一个新数组,不会影响原来的数组,我们也称之为非变异方法
    • some方法,是用来看数组中是否存在符合条件的元素(运行机制:内部也有循环机制,每次循环也会调用函数,只要函数返回true,则终止循环,some函数也返回true,若果循环结束,还没有一个返回true,则some函数返回false)
      • 返回值是布尔值,如果有,则返回true,否则返回false
      • 一旦找到符合条件的,则立即终止循环
      • 当循环逻辑比较复杂或耗时时,可以提高一丢丢性能
    • map方法,用来做映射,返回值是数组,内部会有循环机制…,实参函数的返回值会组成一个新的数组返回
    • every方法,和some类似,但必须每一个都符合条件,才返回true,反之,只要有一个不符合条件,就返回false

    非变异方法和变异方法的区别就是看调用完这个方法后,会不会影响原数组,有则是变异方法,无则是非变异方法

    写代码时,要逐步测试,不要写了一百行,再来测试,如果报错了,这个时候你很可能懵逼,不知道到底是哪一行代码引起的

    forEach和some的区别:

    • forEach不可以通过return终止循环,也不可以使用continue、break
    • some可以通过return true(why? 乌龟的尾巴,死龟腚)终止循环,在只需要找到某个元素时,效率更高

    trim方法:

    • .trim()方法就是去除字符串的前后空格,中间的不会去掉
    var str = '   hello   '
    console.log(str.trim()//hello 去除两端空格
    var str1 = '   he l l o   '
    console.log(str.trim()//he l l o  去除两端空格
    

    Object.keys(obj):

    • Object.keys(obj)返回obj对象自身(拿不到原型链上的属性)的所有键名组成的数组
     var obj = {
         id: 1,
         pname: '小米',
         price: 1999,
         num: 2000
    };
    var result = Object.keys(obj)
    console.log(result)//[id,pname,price,num]
    

    1.1数组方法forEach遍历数组

     arr.forEach(function(value, index, array) {
           //参数一是:数组元素
           //参数二是:数组元素的索引
           //参数三是:当前的数组
     })
      //相当于数组遍历的 for循环 没有返回值
    

    1.2数组方法filter过滤数组

      var arr = [12, 66, 4, 88, 3, 7];
      var newArr = arr.filter(function(value, index,array) {
      	 //参数一是:数组元素
         //参数二是:数组元素的索引
         //参数三是:当前的数组
         return value >= 20;
      });
      console.log(newArr);//[66,88] //返回值是一个新数组
    

    1.3数组方法some

    some 查找数组中是否有满足条件的元素 
     var arr = [10, 30, 4];
     var flag = arr.some(function(value,index,array) {
        //参数一是:数组元素
         //参数二是:数组元素的索引
         //参数三是:当前的数组
         return value < 3;
      });
    console.log(flag);//false返回值是布尔值,只要查找到满足条件的一个元素就立马终止循环
    

    1.4筛选商品案例

    1. 定义数组对象数据

       var data = [{
                   id: 1,
                   pname: '小米',
                   price: 3999
               }, {
                   id: 2,
                   pname: 'oppo',
                   price: 999
               }, {
                   id: 3,
                   pname: '荣耀',
                   price: 1299
               }, {
                   id: 4,
                   pname: '华为',
                   price: 1999
               }, ];
    

    2. 使用forEach遍历数据并渲染到页面中

       data.forEach(function(value) {
         var tr = document.createElement('tr');
         tr.innerHTML = '<td>' + value.id + '</td><td>' + value.pname + '</td><td>' + value.price + '</td>';
         tbody.appendChild(tr);
        });
    

    3. 根据价格筛选数据

    1. 获取到搜索按钮并为其绑定点击事件

          search_price.addEventListener('click', function() {
          });
    

    2. 使用filter将用户输入的价格信息筛选出来

          search_price.addEventListener('click', function() {
                var newDate = data.filter(function(value) {
                  //start.value是开始区间
                  //end.value是结束的区间
                	return value.price >= start.value && value.price <= end.value;
                });
                console.log(newDate);
           });
    

    3. 将筛选出来的数据重新渲染到表格中

      1. 将渲染数据的逻辑封装到一个函数中
             function setDate(mydata) {
                   // 先清空原来tbody 里面的数据
               tbody.innerHTML = '';
               mydata.forEach(function(value) {
                 var tr = document.createElement('tr');
                 tr.innerHTML = '<td>' + value.id + '</td><td>' + value.pname + '</td><td>' + value.price + '</td>';
                   tbody.appendChild(tr);
               });
              }
      2. 将筛选之后的数据重新渲染
              search_price.addEventListener('click', function() {
                  var newDate = data.filter(function(value) {
                  return value.price >= start.value && value.price <= end.value;
                  });
                  console.log(newDate);
                  // 把筛选完之后的对象渲染到页面中
                  setDate(newDate);
             });
    

    4. 根据商品名称筛选

      1. 获取用户输入的商品名称
      2. 为查询按钮绑定点击事件,将输入的商品名称与这个数据进行筛选
              search_pro.addEventListener('click', function() {
                  var arr = [];
                  data.some(function(value) {
                    if (value.pname === product.value) {
                      // console.log(value);
                      arr.push(value);
                      return true; // return 后面必须写true  
                    }
                  });
                  // 把拿到的数据渲染到页面中
                  setDate(arr);
             })
    

    1.5some和forEach区别

    • 如果查询数组中唯一的元素, 用some方法更合适,在some 里面 遇到 return true 就是终止遍历 迭代效率更高
    • 在forEach 里面 return 不会终止迭代
    展开全文
  • 数组去重的方法

    2017-04-28 02:04:03
    包装对象即基本数据类型经过包装之后得到对象,作为基本类型值字符串拥有trim方法,及length属性,正是由于JS代码会对原始值做一次包装,然后变为了字符串对象,再执行相关操作。 // "a".trim()...
        

    NaN

    NaN属于number,也是一种基本数据类型,只要有一边是 NaN,那么结果就是false

    原始值和包装对象

    包装对象即基本数据类型经过包装之后得到的对象,作为基本类型值的字符串拥有trim等方法,及length属性,正是由于JS代码会对原始值做一次包装,然后变为了字符串对象,再执行相关的操作。

        // "a".trim();
        
        //该过程在JS解析过程中真实存在
        var tmp = new String("a");
        tmp.trim();

    原始值和包装对象的区别在于类型不同。这是最根本的区别,而且虽然是包装"对象",但也会有对象的少部分特性,比如:

        var A = new String("a");
        var B = new String("a");
        var C = "a";
        A == B //false
        A == C //true 

    对象和对象

    对象可以分为三种:纯对象(plain object)、实例对象、其他类型的对象。

     纯对象指由字面量生成,成员中不含函数和日期、正则表达式等类型的对象。             

    纯对象

    一元操作符会对对象隐式转换,对象会先调用valueOf方法,然后是toString方法,直到能转换为基本数据类型为止。

    而判断两个对象是不是相等时,因为对象保存在堆内存,只有两个对象引用同一个地址,才会相等:

        {} == {}//false
        var a = new Object();
        var b = a;
        console.log(a == b)

    如果需要比较两个对象的键名键值对是否相等,可以采取JSON.stringify的方法转换后再比较。

    实例对象

    通过构造函数生成的对象,这样的对象和纯对象一样无法直接进行外部比较是否相等,可以使用构造函数(类)提供静态方法或实例方法来判断是否相等。

    其他对象

    指的数组、日期、正则表达式等Object衍生出来的对象,一般需要根据使用场景来构造判断方法,决定两个对象是否相等。

    例如日期对象要通过Data.prototype.getTime()方法来获取时间戳判断是否表示同一个时刻,正则需要toString获取原始字面量来判断是否是相同的正则表达式。

    == 和 ===

    如果判断元素是否相等的方法中,采用的是==比较运算,两边的数据会发生隐式类型转换,这就造成了影响判断结果的因素。

    在判断Boolea、Number、String三种类型进行不同类型的 == 比较时,规则是将其转化为数字之后再比较是否相等。

        console.log( "ac" == true )//false
        console.log(123 == "123");//true

    而undefined表示"缺少值",就是此处应该有一个值,但是还没有定义。它会被转换成数字,而转换结果为NaN,NaN不等于任何值,所以undefined != false;对于null来说,null表示"没有对象",即该处不应该有值。首先调用Object.valueOf方法返回基本类型值之后在比较,所以null != false
    最后一点是undefined == null,这是ECMA-262标准 11.9.3 节的规定。

    去重的方法

    Array.prototype.indexOf()

        let arr = [12,12,9,2,0,9,8];
        /*
            例如:12第一次出现在0,之后再出现时index为1,
            说明第二个是重复值,所以只返回第一个12,
            但是对于NaN而言indexOf只会为-1,所以不管有几个NaN都会直接跳过
        */
        function unique(arr){
            return arr.filter(function(value,index){
                return arr.indexOf(value) === index;
            })
        }
        
        //indexOf(NaN)则一直为-1,数组中会出现一个或多个NaN(如果存在)
        function unique(arr){
            let ret = [];
            arr.forEach(function(value){
                if(ret.indexOf(value) === -1){
                    ret.push(value);
                }
            })
            return ret;
        }
        console.log(unique(arr));

    在规范中,indexOf()使用的是全等比较,只要有NaN都是无法判断位置直接跳过的。

    
        全等比较不能处理NaN的相等性判断,NaN不等于任何值,包括本身。
    

    Array.prototype.includes()

    Array.prototype.includes()是ES6中新增的方法,判断数组中是否包含某个元素,上一中indexOf方法可以修改为:

        function unique(arr){
            let ret = [];
            arr.forEach(function(value){
                if(!ret.includes(value)){
                    ret.push(value);
                }
            })
            return ret;
        }

    includes()方法内部的比较方法是:"SameValueZero",详细规则:

        1. If Type(x) is different from Type(y), return false.
    
        2. If Type(x) is Number,then
        
            a. If x is NaN and y is NaN, return true.
            
            b. If x is +0 and y is -0, return true.
            
            c. If x is -0 and y is +0, return true.
            
            d. If x is the same Number value as y, return true.
            
            e. Return false.
        
        3. Return SameValueNonNumber(x, y).

    注意:如果x、y都是NaN,则返回true,所以includes方法可以判断是否包含了NaN

        var arr = [12,1,"d3",NaN];
        console.log(arr.includes(NaN));//true

    由此可见indexOf和includes方法对NaN待的行为不一样。

    其他的方法

    遍历

    遍历是最基本也是最容易想到的方案:

        function unique(arr){
            let isRepeate;
            let ret = [];
            for(var i = 0;len = arr.length,i<len;i++){
                isRepeate = false;
                for(var k = i+1;k<len;k++){
                    if(arr[i] === arr[k]){
                        isRepeate = true;
                        break;
                    }
                }
                if(!isRepeate){
                    ret.push(arr[i]);
                }
            }
            return ret;
        }

    去重的部分也是全等操作符实现的,所以对于数组中的NaN而言也会都push进入ret之后返回。

    Map Key

    Map是一种新的数据类型,就是key的类型没有限制的对象,它的存取使用单独的get、set接口。因为使用单独的接口存取数据,所以不用担心key与内置属性重名,修改上面的方法后得到:

        function unique(arr){
            let ret = [];
            let len = arr.length;
            let tmp = new Map();
            for(let i = 0;i<len;i++){
                if( !tmp.get(arr[i]) ){
                    tmp.set(arr[i],1);
                    ret.push(arr[i]);
                }
            }
            return ret;
        }
    set

    除了Map以外,还有Set这种数据类型,这是一个集合,它不允许重复元素出现。
    如果重复添加相同的元素,只会储存其中的一个,包括NaN在内。如果将这种特性与数组交换,那么数组就可以直接去重了。

        function unique(arr){
            let ret = new Set(arr);
            return Array.from(set);
        }
    展开全文
  • console.log([].slice.call(arguments))// 因为[]是数组的实例,所以[]也有slice方法,call方法必须由函数调用,不能直接对象.call } fn1(123, "abc"); //...
    <!DOCTYPE html>
    <html>
    
    	<head>
    		<meta charset="UTF-8">
    		<title></title>
    	</head>
    
    	<body>
    		<h4>1111</h4>
    		<h4>2222</h4>
    		<h4>3333</h4>
    		<script type="text/javascript">
    			var str = "book";
    			var num = 123;
    			//function String(){
    			//	console.log("string...")
    			//}
    			console.log(str.length, num.length);
    			console.log("String", String);
    			var init;
    			String.prototype.get = function() {
    				console.log(this);
    				init = this;
    				return "好好学习"
    			}
    			var str2 = " go od ";
    			console.log(str2.length);
    			var strO = new String("  happy NewYear ");
    			console.log(strO, strO.get(), init === strO); //true
    			console.log(strO.trim().length);
    
    			var str3 = " th a  nk  ";
    			if(!String.prototype.trim) {
    				String.prototype.trim = function() {
    					return this.replace(/(^\s+|\s+$)/g, ""); //去掉空格
    				}
    			}
    			String.prototype.trimAll = function() {
    				return this.replace(/\s+/g, ""); //去掉所有空格
    			}
    			console.log(str3.trim().length, str3.trim(), str3.trimAll());
    			console.log("-------------------------------------------------");
    			console.log(Array.prototype.indexOf);
    			var objToString = Object.prototype.toString;
    			var arrSlice = Array.prototype.slice;
    			var doms = document.getElementsByTagName("h4");
    			console.log(doms, objToString.call(doms));
    
    			function fn1() {
    				console.log(arguments, objToString.call(arguments));
    				//console.log(arguments.slice(1)) 出错  arguments不是数组,不具有数组的方法
    				var a1 = arrSlice.call(arguments, 1);
    				console.error(a1) //成立
    				var aa = arrSlice.call(arguments); //将类数组转为数组
    				console.log(aa);
    				var arr = [1, 4, 'd'];
    				console.log(arr.slice());
    				var a2 = Array.prototype.splice(arguments);
    				console.log(a2) //[]
    				console.log([].slice.call(arguments))// 因为[]是数组的实例,所以[]也有slice方法,call方法必须由函数调用,不能直接对象.call
    
    			}
    			fn1(123, "abc");
    			//https://www.cnblogs.com/guorange/p/6668440.html
    			//slice的内部实现
    			Array.prototype.slice = function(start, end) {
    				var result = new Array();
    				start = start || 0;
    				end = end || this.length; //this指向调用的对象,当用了call后,能够改变this的指向,也就是指向传进来的对象,这是关键  
    				for(var i = start; i < end; i++) {
    					result.push(this[i]);
    				}
    				return result;
    			}
    		</script>
    	</body>
    
    </html>

    展开全文
  • 创建一个形参为char数组的Trim方法,通过将输入的字符串转换为char数组的方式传递参数 在Trim方法中,对传递后的char数组进行遍历查询。 先检查数组的开头,如果开头存在空格,则将数组从后往前赋值,从而使开头的...
  • 数组方法(forEach,filter,some)和字符串trim方法和Object.keys(对象),Object.defineProperty 1.数组方法forEach遍历数组 arr.forEach(function(value,index,array){ //参数1:数组元素; //参数2:数组元素索引 //...
  • join,就是把数组转换成字符串,然后给他规定个连接字符,默认是逗号( ,),书写格式:join(" "),括号里面写字符串 (“要加引号”), var arr = [1,2,3]; console.log(arr.join()); // 1,2,3 console.log(arr.join...
  • 几种php删除数组元素方法在很多情况下我们的数组会出现重复情况,那我们删除数组中一些重复内容怎么办,这些元素必须保持他唯一,所以就想办法来删除它们,下面利用了遍历查询来删除重复数组元素几种方法。...
  • 方法一: function array_remove_value(&$arr, $var) { foreach ($arr as $key => $value)  { if (is_array($value))  { array_remove_value($arr[$key], $var); } else  { $value = trim($value); ...
  • 本文实例讲述了php把数组值转换成键的方法。分享给大家供大家参考。具体如下: function values2keys($arr, $value=1){ $new = array(); while (list($k,$v) = each($arr)){ $v = trim($v); if ($v != ''){ $...
  • 数组方法 迭代(遍历)方法 forEach() array.forEach(function(currentValue,index,arr)) currentValue数组当前项值 index数组当前项索引 arr数组对象本身 <script> // forEach 迭代(遍历) 数组 var arr...
  • js trim方法的实现

    2019-08-17 10:10:40
    2、用法:创建一个字符串,直接使用它的trim方法,因为字符串在使用属性和方法时会隐式的创建包装对象,所以基本数据类型 string 也可以使用方法 。使用后收尾的空字符全部被删除,但中间的空字符不会被删除 ,如下...
  • php对多维数组的某个键值排序方法

    千次阅读 2016-12-10 10:43:02
    function:二维数组按指定键值排序 author:www.111cn.net */ function array_sort($array,$keys,$type='asc'){ if(!isset($array) || !is_array($array) || empty($array)){ return ''; } if(!isset($keys) || trim...
  • jQuery的each方法是可以遍历伪数组的 /* 第一个参数: 当前遍历到的索引 第二个参数: 遍历到的元素 */ $ . each ( arr , function ( index , value ) { console . log ( index , value ) ; ...
  • forEach相当于增强版的for循环,回调函数有三个参数分别为:每个遍历数组的值,每个遍历数组的索引,数组本身。 var arr = [1, 2, 3, 4, 5, 6]; var sum = 0; //forEach arr.forEach(function (value, index, ...
  • 本文实例讲述了PHP实现二维数组按指定键名排序的方法。分享给大家供大家参考,具体如下: <?php /*二维数组按指定键值排序*/ function array_sort($array,$keys,$type='asc'){ if(!isset($array) || !is_...
  • 使用MyBatis插入一个一个,前缀prefix,或者分割符号不对话,可能就会极大不方便,这里MyBatis自带用方法 trim用法,自己判断前缀后缀 <trim prefix="set" suffixOverrides=","> 前缀是set,后缀是, </...
  • 本文实例讲述了PHP清除数组中所有字符串两端空格的方法,分享给大家供大家参考。具体实现方法如下: 一般来说在php中清除字符串中空格我们可以有很多实现方法,但清除数组中所有值前后代码我们并不能简单使用...
  • ES6新特性 字符串新方法 1. 变量名.includes( '字符') 判断字符串中是否包含某字符 ...2.变量名.trim( ) 返回新字符串 去除头尾空格 var x = ' abcdefg ' console.log(x.trim()) -------结果-----...
  • 表单修饰符 .lazy 在默认情况下,v-model在每次input触发后将输入框值与数据进行同步,使用.lazy修饰符,从而转变为使用change事件改变数据 ...数组方法 push():向数组末端添加一个或多个元素,返回数组...
  • java当中trim方法是干什么用 好像记得是数组对象才可以调用此方法是吧
  •  自己实现trim方法    1.将字符串转换为char类型数组buf  2.遍历buf数组,将第一个非空格字符之前所有空格删除,保存为一个新数组buf1  3.遍历buf1数组,将最后一个非空格字符之后所有空格山删除,保存为一...
  • 数组方法 对象方法 字符串方法 1.去除两端空白字符:解决获取字符串有空格bug(搜索框bug问题) 代码:var 新字符串 = 字符串.trim(空) 返回值:新字符串 2.将原字符串进行重复,返回一个新字符串 var lzy = ...
  • public boolean isNullOrLengthZero(String[] args) { if (args != null && args.length != 0) { for (int i = 0; i ; i++) { if (args[i] == null || args[i].trim().length() == 0) 
  • 思路是先对用户输入进行验证,即先用trim()函数过滤用户输入字符串左右空格,若结果为空字符串则用JOptionPane类showMessageDialog方法提示用户"请输入数字内容"。若用户输入非空则使用charAt函数对用户输...
  • 不过这个方法还是略显复杂,下面分享一下今天看到一个方法,非常简洁/*** 方法库-数组去除空值* @param string $num 数值* @return string*/public function array_remove_empty(&$arr, $trim = tru...
  • 1.$.trim(str) 去掉字符串首尾空格。...两个方法是有区别,从而这两个方法在针对不同操作上,显示了各自特点。 2.$().each,对于这个方法,在dom处理上面用较多。如果页面有多个inpu...
  • 您可以通过计算单个布尔数组和^{}来使用向量化方法。或者,您可以通过for循环或带有生成器表达式0元素计算第一行索引。在为了提高性能,我建议您将^{}与手动for循环一起使用。这里有一个例子,但请参见下面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 425
精华内容 170
关键字:

数组的trim方法