1.用VBA做自动更新高级筛选 我做个高级筛选但不能自动更新，想请教各位如何用VBA做。
2.JavaScript中利用Array filter() 方法压缩稀疏数组
3.如何不规则切图
4.I/O源码分析(3)--BufferedOutputStream之秒懂"flush"
5.polars源码解析——DataFrame

用VBA做自动更新高级筛选 我做个高级筛选但不能自动更新，想请教各位如何用VBA做。

       从以下的示例中，以及FILTE这个对象的linux红帽源码包属性来看，无法遍历筛选列出的项目。我觉的可以换个方法，例如生成透视表，再遍历透视表中的值，然后再删除透视表。

       Dim w As Worksheet

       Dim filterArray()

       Dim currentFiltRange As String

       Sub ChangeFilters()

       Set w = Worksheets("Crew")

       With w.AutoFilter

        currentFiltRange = .Range.Address

        With .Filters

        ReDim filterArray(1 To .Count, 1 To 3)

        For f = 1 To .Count

        With .Item(f)

        If .On Then

        filterArray(f, 1) = .Criteria1

        If .Operator Then

        filterArray(f, 2) = .Operator

        filterArray(f, 3) = .Criteria2

        End If

        End If

        End With

        Next

        End With

       End With

       w.AutoFilterMode = False

       w.Range("A1").AutoFilter field:=1, Criteria1:="S"

       End Sub

JavaScript中利用Array filter() 方法压缩稀疏数组

       什么是稀疏数组

       数组元素的索引不一定要连续的，它们之间可以有空缺。怎样复制整站源码每个javaScript数组都有一个length属性。针对非稀疏数组，该属性就是数组元素的个数；针对稀疏数组，length比所有元素的个数要大。

       Array

       filter()

       方法会跳过稀疏数组中缺少的元素，它的返回数组总是稠密的。

       (1)压缩稀疏数组的空缺：

       var

       dense

       =

       sparse.filter(

       function(currentValue)

       {

       return

       true;

       }

       );

       (2)压缩稀疏数组的空缺，并且删除

       undefined

       和

       null

       元素：

       var

       dense

       =

       sparse.filter(

       function(currentValue)

       {

       return

       currentValue

       !==

       undefined

       &&

       currentValue!=

       null;

       }

       )

       总结

       以上所述是小编给大家介绍的JavaScript中利用Array

       filter()

       方法压缩稀疏数组，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的astgo改号源码支持！

       您可能感兴趣的文章:javascript稀疏数组(sparse

       array)和密集数组用法分析JavaScript中的稀疏数组与密集数组[译]

如何不规则切图

       ä¸‹è½½äº†ä¸€ä½å¤§ç¥žçš„代码，是AS2.0的，看不太懂，想改成3.0的。以前从没接触过贴图，不过我知道大体精髓是不规则区域的填充，摸索了一下，用.beginBitmapFill方法填充。剩下画图，要根据不同情况来（有8种情况吧）。好多功能没有，比较简陋，希望能帮到对bitmap不熟的朋友。菜鸟一枚，代码都是写在时间轴上的。

       import flash.display.Sprite;

       import flash.display.Loader;

       import flash.net.URLRequest;

       import flash.display.BitmapData;

       import flash.events.Event;

       import flash.events.MouseEvent;

       import flash.filters.GlowFilter;

       import flash.filters.DropShadowFilter;

       var spArray:Array = new Array();

       var rows,cols,w,h,i,j,m,n:Number;

       var filterArray:Array = new Array();

       //定义行数列数

       rows = ;

       cols = 8

       //画曲线的重要参数，curWidth为贝塞尔曲线的参数

       var curWidth:Number;

       var ellipseA:Number;

       var ellipseB:Number;

       //加载图片

       var url = new URLRequest("1.jpg");

       var _loader = new Loader();

       _loader.load(url);

       _loader.contentLoaderInfo.addEventListener(Event.COMPLETE,onImgLoad);

       //定义滤镜

       var color1:Number = 0xCCFF;

       var alp1:Number = 0.8;

       var blurX1:Number = 2;

       var blurY1:Number = 2;

       var strength1:Number = 2;

       var quality1:Number = 3;

       var inner1:Boolean = false;

       var knockout1:Boolean = false;

       var filter1:GlowFilter = new GlowFilter(color,alp1,blurX1,blurY1,strength1,quality1,inner1,knockout1);

       filterArray.push(filter1);

       var splArray:Array = new Array();

       var distance:Number = 3;

       var angleInDegrees:Number = 3;

       var color:Number = 0x;

       var alp:Number = 0.8;

       var blurX:Number = 3;

       var blurY:Number = 3;

       var strength:Number = 1;

       var quality:Number = 3;

       var inner:Boolean = false;

       var knockout:Boolean = false;

       var hideObject:Boolean = false;

       var filter:DropShadowFilter = new DropShadowFilter(distance,angleInDegrees,color,alp,blurX,blurY,strength,quality,inner,knockout,hideObject);

       filterArray.push(filter);

       //对每个格子的形状初始化,如果left, right, up, down全部为true表示四面有填充的椭圆

       for (i = 0; i < rows; i ++)

       {

        for (j = 0; j < cols; j++)

        {

        var ms:MySplit = new MySplit(i,j);

       //首先调用随机数，确认本格右方和下方是否填充

        m = int(Math.random() * 2);

        n = int(Math.random() * 2);

        if (m == 1 && j < cols - 1)

        {

        ms.right = true;

        }

        if (n == 1 && i < rows - 1)

        {

        ms.down = true;

        }

        //检测本格左方是否需要填充

        if (j > 0 &&! splArray[i * cols + j - 1].right)

        {

        ms.left = true;

        }

        //检测本格上方是否需要填充

        if (i > 0 && ! splArray[(i - 1) * cols + j].down)

        {

        ms.up = true;

        }

        splArray.push(ms);

        }

       }

       //主处理函数

       function onImgLoad(event:Event):void

       {

        var bitmap:BitmapData = new BitmapData(_loader.width,_loader.height);

        w = _loader.width / cols;

        h = _loader.height / rows;

        //curWidth始终设为较小边的四分之一。以适应长宽比很不和谐的画面

       curWidth = h < w? h / 4 : w /4;

        //ellipseA始终较大,这样可以适应竖着或横着的椭圆

        ellipseA = h > w ? h / 5:w / 5;

        ellipseB = h < w? h / 5: w /5;

        //逐个分割图片

        for (i = 0; i < rows; i ++)

        {

        for (j = 0; j < cols; j++)

        {

        bitmap.draw(_loader);

        var sampleSprite:Sprite = new Sprite();

        sampleSprite.graphics.lineStyle();

        sampleSprite.graphics.beginBitmapFill(bitmap);

        myDraw(sampleSprite, splArray[i*cols + j]);

       sampleSprite.graphics.endFill();

        if (_loader.width > )

        {

        sampleSprite.scaleX = / (w * rows);

        sampleSprite.scaleY = / (w * rows)

        }

        sampleSprite.x = 2 * j ;

        sampleSprite.y = 2 * i ;

        addChild(sampleSprite);

        sampleSprite.filters = filterArray;

        spArray.push(sampleSprite);

        sampleSprite.addEventListener(MouseEvent.MOUSE_DOWN, onDown);

        sampleSprite.addEventListener(MouseEvent.MOUSE_UP, onUp);

        }

        }

       }

       //画图函数

       function myDraw(sprite:Sprite, ms:MySplit)

       {

        sprite.graphics.drawRoundRect(j * w, i * h, w, h, 5, 5);

        if (ms.right)

        {

        sprite.graphics.moveTo(w*(j+1), i*h);

        sprite.graphics.curveTo(w*(j+1) - curWidth, i * h + h / 2, w*(j+1), (i+1)*h);

        sprite.graphics.drawEllipse(w*(j+1)-0.5*curWidth, i*h+0.5*h-0.5*ellipseA,ellipseB,ellipseA);

        }

        else if(j < cols - 1)

        {

        sprite.graphics.moveTo(w*(j+1), i*h);

        sprite.graphics.curveTo(w*(j+1) + curWidth, i * h + h / 2, w*(j+1), (i+1)*h);

        sprite.graphics.drawEllipse(w*(j+1)+0.5*curWidth - ellipseB, i*h+0.5*h-0.5*ellipseA,ellipseB,ellipseA);

        }

        if (ms.left)

        {

        sprite.graphics.moveTo(w*j, i*h);

        sprite.graphics.curveTo(w*j + curWidth, i * h + h / 2, w*j, (i+1)*h);

        sprite.graphics.drawEllipse(w*j+0.5*curWidth - ellipseB, i*h+0.5*h-0.5*ellipseA,ellipseB,ellipseA);

        }

        else if (j > 0)

        {

        sprite.graphics.drawEllipse(w*j-0.5*curWidth, i*h+0.5*h-0.5*ellipseA,ellipseB,ellipseA);

        sprite.graphics.moveTo(w*j, i*h);

        sprite.graphics.curveTo(w*j - curWidth, i * h + h / 2, w*j, (i+1)*h);

        }

        if (ms.down)

        {

        sprite.graphics.moveTo(w*j, (i+1)*h);

        sprite.graphics.curveTo(w*j+0.5*w, (i+1) * h - curWidth, (j+1)*w, (i+1)*h);

        sprite.graphics.drawEllipse(w*j+0.5*w - 0.5*ellipseA, (i+1)*h-0.5*curWidth, ellipseA,ellipseB);

        }

        else if(i < rows - 1)

        {

        sprite.graphics.moveTo(w*j, (i+1)*h);

        sprite.graphics.curveTo(w*j+0.5*w, (i+1) * h + curWidth, (j+1)*w, (i+1)*h);

        sprite.graphics.drawEllipse(w*j+0.5*w - 0.5*ellipseA, (i+1)*h+0.5*curWidth - ellipseB,ellipseA,ellipseB);

        }

        if (ms.up)

        {

        sprite.graphics.moveTo(w*j, i*h);

        sprite.graphics.curveTo(w*j+0.5*w, i * h + curWidth, (j+1)*w, i*h);

        sprite.graphics.drawEllipse(w*j+0.5*w - 0.5*ellipseA, i*h+0.5*curWidth - ellipseB,ellipseA,ellipseB);

        }

        else if (i > 0)

        {

        sprite.graphics.moveTo(w*j, i*h);

        sprite.graphics.curveTo(w*j+0.5*w, i * h - curWidth, (j+1)*w, i*h);

        sprite.graphics.drawEllipse(w*j+0.5*w - 0.5*ellipseA, i*h-0.5*curWidth,ellipseA,ellipseB);

        }

       }

       function onDown(e:MouseEvent)

       {

        e.target.startDrag();

       }

       function onUp(e:MouseEvent)

       {

        e.target.stopDrag();

       }

       å¤åˆ¶ä»£ç 

I/O源码分析(3)--BufferedOutputStream之秒懂"flush"

       本文基于JDK1.8，深入剖析了BufferedOutputStream的源码，帮助理解缓冲输出流的工作机制。

       BufferedOutputStream，作为与缓冲输入流相对应的面向字节的IO类，其主要功能是通过write方法进行字节写出操作，并在调用flush方法时清除缓存区中的剩余字节。

       其继承体系主要包括了基本的输出流类，如OutputStream。

       相较于缓冲输入流，BufferedOutputStream的方法相对较少，但功能同样强大。好友宝程序源码

       BufferedOutputStream内部包含两个核心成员变量：buf代表缓冲区，count记录缓冲区中可写出的字节数。

       构造函数默认初始化缓冲区大小为8M，若指定大小则按指定大小初始化。

       BufferedOutputStream提供了两种主要的写方法：write(int b)用于写出单个字节，以及write(byte[] b, int off, int len)用于从数组中写出指定长度的字节。在内部实现中，使用System.arraycopy函数加速字节的复制过程。

       对于上述方法在调用之后，均会进行缓冲区的清空操作，即调用内部的flushBuffer()方法。然而，传奇源码贴吧用户直接调用的公有flush()方法有何意义呢？

       在实际应用中，当使用BufferedOutputStream进行高效输出时，用户可能需要在程序结束前调用flush()方法，以确保所有未输出的字节都能被正确处理。避免了在程序未结束时输出流的缓存区中出现未输出的字节。

       flush()方法内部逻辑简单，主要通过调用继承自FilterOutputStream的out变量的flush()方法实现缓存区的清空，并将缓冲区的字节全部输出。同时，由于Java的IO流采用装饰器模式，该过程也包括了调用其他实现缓冲功能类的flush方法。

       为验证flush()方法的功能，本文进行了简单的测试，通过初始化缓冲区大小为5个字节，分别测试了不调用flush()、调用close()与不调用flush()、不调用close()的情况。

       测试结果显示，不调用flush()而调用close()时，输出为一个特殊符号，表明字节被正确输出。而在不调用flush()且不调用close()的情况下，输出为空，说明有字节丢失。

       值得注意的是，如果在测试时定义的字节数组长度超过缓冲区大小，BufferedOutputStream可能直接使用加速机制全部写出，无需调用flush()。

       综上所述，使用BufferedOutputStream时，养成在程序结束前调用flush()的习惯，能有效避免因缓存区未清空导致的数据丢失问题，确保程序的稳定性和可靠性。

polars源码解析——DataFrame

       本文将深入剖析polars中DataFrame的核心构造与关键函数，如select、filter和groupby。DataFrame在polars-core的底层，基于Vec容器构建，其结构简单，由一系列Series构成，能够直接利用Vec的特性，如pop和is_empty。

       select函数的执行流程涉及select_impl和select_series_impl。filter功能虽简单，但采用多线程技术提升性能，如take和sort操作。关于groupby，它首先通过接收一个基于列的迭代器进行分组，选定列后，调用groupby_with_series生成GroupBy结构，用于后续的聚合操作。

       groupby的核心在于groupby_with_series，它根据传入的列名进行分组，构建GroupsProxy对象。group_tuples方法根据不同情况使用SortedSlice或Idx存储分组信息。在对DataFrame按"date"列分组并计算"temp"列数量的例子中，首先进行select操作，确定聚合列，然后执行count聚合。

       在执行聚合时，polar利用groups中的索引获取分组数据，通过ChunkedArray进行并行计算，显著提高了性能。整体来看，DataFrame的这些操作都在巧妙地利用了数据结构和并行计算的优势。