working on it ...

Filters

Explore Public Snippets

Sort by

Found 2.9M snippets

    public by KrasnokutskiyEA  6  0  1  0

    scale

    // создаем шкалу: функцию scale(x).
    
    // ['a', 'b', 'c', 'd'] - domain - входной диапазон
    // ['red', 'blue', 'green', 'orange'] - range - выходной диапазон
    
    let scale = d3.scaleOrdinal(['red', 'blue', 'green', 'orange']).domain(['a', 'b', 'c', 'd'])
    
    scale('c') // 'green'

    public by gwarah  44  1  5  0

    Validação de CPF/CNPJ em HTML

    Este snippet é usado para teste de outro snippet que contém as classes javascript Cpf e Cnpj. Busque por "Validação de CPF/CNPJ em javascript" no meu canal.
    <html>
    <head>
    	<title>validação de CPFs/CNPJ</title>
    </head>
    <body>
        <!-- included this snippet -->
        <script src="cnpj_cpf.js"></script>
    <script type="text/javascript">
    
        function WinLoad() {
            document.getElementById("bt_cpf").addEventListener("click", validar_cpf, false);
            document.getElementById("bt_cnpj").addEventListener("click", validar_cnpj, false);
        }
        
        window.onload = WinLoad;
        
        // validação de CPF
        function validar_cpf() {
            let p_cpf=document.getElementById("txt_cpf").value;
            let v_cpf=new Cpf(p_cpf);
            // alert("cheguei aqui" + p_cpf);
            v_cpf.validar();
            document.getElementById("div_resultado_cpf").innerHTML = v_cpf.show_status();
            return true;
        }
        
        // validação de CNPJ
        function validar_cnpj() {
            let p_cnpj=document.getElementById("txt_cnpj").value;
            let v_cnpj=new Cnpj(p_cnpj);
            // alert("cheguei aqui" + p_cnpj);
            v_cnpj.validar();
            document.getElementById("div_resultado_cnpj").innerHTML = v_cnpj.show_status();
            return true;
        }
    </script>
    
    <p>Validação do CPF/CNPJ</p>
    
    <p>
    CPF: 
    <input type="text" id="txt_cpf" value=""> 
    <input type="button" id="bt_cpf" value="Validar">
    </p><br>
    <div id="div_resultado_cpf">não validado</div>
    
    <p>
    CNPJ: 
    <input type="text" id="txt_cnpj" value=""> 
    <input type="button" id="bt_cnpj" value="Validar">
    </p><br>
    <div id="div_resultado_cnpj">não validado</div>
    
    </body>
    </html>
    																																																						

    public by gwarah  47  2  4  0

    Validação de CPF/CNPJ em javascript

    Classes em javascript para validação de números de CPFs e CNPJs. Requisitos: browser ou ferramenta deve suportar a ECMAScript® 2015 Language Specification Obs:Em outro snippet há o código HTML para testar estas classes
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
     * Arquivo      : cnpj_cpf.js
     * Observações  :
     *   #version;date;description
     *   0.1.0;20/12/2019; versão beta1
     */
    
    /**
     * Class: Cpf
     * version: 0.1.0;18/12/2019
     */
     
    class Cpf {
        /* constructor */
        constructor(p_cpf) {
            
            // validações iniciais
            if ( typeof p_cpf !== 'string' ) {
                throw "Parâmetro p_cpf " + p_cpf + " deve ser do tipo string!";
            }
            
            // retira não numéricos
            p_cpf = p_cpf.replace(/\D/g,'');
                   
            /* attributes */
            this._cpf = p_cpf;   // retira não numéricos
            this._er = /^[0-9]{11}$/;
            this._er_mask = /^[0-9]{3}\.?[0-9]{3}\.?[0-9]{3}\-?[0-9]{2}$/;
            this._status = 0;   // 0-não testado;1-válido;2-inválido
        }
    
    
        /* getters and setters */
        get cpf() {
            return this._cpf;
        }
        
        set cpf(p_cpf) {
            // validações iniciais
            if ( typeof p_cpf !== 'string' ) {
                throw "Parâmetro p_cpf " + p_cpf + " deve ser do tipo string!";
            }
            
            // retira não numéricos
            p_cpf = p_cpf.replace(/\D/g,'');   // retira não numéricos
            
            // atribuição
            this._cpf = p_cpf;
            this._status = 0;
        }
    
        get status() {
            return this._status;
        }
    
        /* others methods */
        validar() {
           this._status = ( this._validarCpf(this._cpf) ? 1 : 2);
           return ( this._status == 1 ) ? true : false;
        }
    
        show_status() {
            let str_out='CPF: ' + this._cpf + ' - status: ' + this._status;
            console.log(str_out);
            return str_out;
        }
    
        /* functions */
            
        //
        // validação de CPF
        //
        _validarCpf(p_cpf) {
    
            //
            // testes iniciais: descarta nulos, não strings e string que não é numérica de 11 dígitos
            //
    
            if ( typeof p_cpf !== 'string' ) { return false; }
    
            if ( ! ( this._er.test(p_cpf)) ) { return false; }
    
            //
            //  regra de validação do CPF
            //
    
            // quebra o CPF em 2 partes
            let cpf9digs=p_cpf.substring(0,9);
            let cpf2digs=p_cpf.substring(9,11);
    
            let soma=0;
            let digv="";
            let digv1=0;
            let digv2=0;
            let p=0;
            let dig=0;
            let mod11soma=0;
    
            // obtenção do primeiro dígito
            for(p=10;p>=2;p--) {
                dig=parseInt(cpf9digs.charAt(10-p));
                soma+=p*dig;
            }
            mod11soma = soma % 11;
            digv1=(mod11soma<2) ? 0 : (11-mod11soma);
    
            // obtenção do segundo dígito
            let cpf10digs= "" + cpf9digs + digv1;
            soma=0;
            digv2=0;
            for(p=11;p>=2;p--) {
                dig=parseInt(cpf10digs.charAt(11-p));
                soma+=p*dig;
            }
            mod11soma = soma % 11;
            digv2 = (mod11soma<2) ? 0 : (11-mod11soma);
    
            // dígito verificador completo
            digv= "" + digv1 + digv2;
    
            return (( digv === cpf2digs ) ? true : false);
        }
    }
    
    /**
    * Class: Cnpj
    * version: 0.1.0;18/12/2019
    */
    class Cnpj {
    
        /* getters and setters */
        constructor(p_cnpj) {
            
            // validações iniciais
            if ( typeof p_cnpj !== 'string' ) {
                throw "Parâmetro p_cnpj " + p_cnpj + " deve ser do tipo string!";
            }
            
            // retira não numéricos
            p_cnpj = p_cnpj.replace(/\D/g,'');
    
            /* attributes */
            this._cnpj = p_cnpj;
            this._er = /^[0-9]{14}$/;
            this._er_mask = /^[0-9]{2}\.?[0-9]{3}\.?[0-9]{3}\/?[0-9]{4}\-?[0-9]{2}$/;
            this._status = 0;   // 0-não testado;1-válido;2-inválido
        }
    
        /* getters and setters */
        get cnpj() {
            return this._cnpj;
        }
    
        set cnpj(p_cnpj) {
            // validações iniciais
            if ( typeof p_cnpj !== 'string' ) {
                throw "Parâmetro p_cnpj " + p_cnpj + " deve ser do tipo string!";
            }
            
            // retira não numéricos
            p_cnpj = p_cnpj.replace(/\D/g,'');
            this._cnpj = p_cnpj;
        }
    
        /* others methods */
        get status() {
            return this._status;
        }
    
        /* others methods */
        validar() {
           this._status = ( this._validarCnpj(this._cnpj) ? 1 : 2);
           return ( this._status == 1 ) ? true : false;
        }
    
        show_status() {
            let str_out='CNPJ: ' + this._cnpj + ' - status: ' + this._status;
            console.log(str_out);
            return str_out;
        }
    
        /* functions */
            
        //
        // validação de CPF
        //
        _validarCnpj(p_cnpj) {
            //
            // testes iniciais: descarta nulos, não strings e string que não é numérica de 11 dígitos
            //
            
            if ( typeof p_cnpj !== "string" ) { return false; }
        
            let ereg = new RegExp('^\\d{14}$');
            if ( ! ( ereg.test(p_cnpj)) ) { return false; }
        
            //
            //  regra de validação do CNPJ
            //
            
            // quebra o CPF em 2 partes
            let cnpj12digs=p_cnpj.substring(0,12);
            let cnpj2digs=p_cnpj.substring(12,14);
            
            let soma=0;
            let digv1=0;
            let digv2=0;
            let dig=0;
            let p=0,i=0;
            let digv="";
            let mod11soma=0;     
        
            //
            // regra de validação do CNPJ
            //
            
            // obtenção do primeiro dígito
            soma=0;
            digv1=0;
            p=2; // peso inicial
            for(i=12;i>=1;i--) {
                dig = parseInt(cnpj12digs.charAt(i-1));
                soma += p * dig;
                p= (p==9) ? 2 : (p+1);
            }
            mod11soma = soma%11;
            digv1= (mod11soma<2) ? 0 : (11-mod11soma);
        
            // obtenção do segundo dígito
            let cnpj13digs="" + cnpj12digs + digv1;
            soma=0;
            digv2=0;
            p=2; // peso inicial
            for(i=13;i>=1;i--) {
                dig=parseInt(cnpj13digs.charAt(i-1));
                soma += p * dig;
                p=(p==9) ? 2 : (p+1);
            }
            mod11soma=soma%11;
            digv2=(mod11soma<2)?0:(11-mod11soma);
            
            // dígito verificador completo
            digv="" + digv1 + digv2;
            
            return (( digv == cnpj2digs ) ? true : false);
        }
    }
    
    																																																

    public by alihilal  29  0  4  1

    Remove all leading and trailing white spaces of string in Swift

    handy Swift string extension that helps to remove all leading and trailing white spaces in a string https://www.alihilal.com/snippets?id=swift-remove-whitespace-string
    import  Foundation
    extension String {
         func  strip()  -> String{ 
             return   self.trimmingCharacters(in: CharacterSet.whitespaces)
            }
    }
    // White spaced string
    var string = "    Hello, World   "
    string.strip()
    //Result -> "Hello, World"
    
    																																				

    public by gwarah  38  0  4  0

    Validação de CPF/CNPJ em awk/bash

    Validação de CPF/CNPJ em awk. Para testar, no shell digite: echo | awk -f cnpj_cpf.awk echo $? Obs: 1. pode ser passada uma lista de CPFs ou CNPJs, um em cada linha da entrada padrão 2. o script retorna 0 se todos os CPFs/CNPJs forem válidos, do contrário retorna 1 Obs: testado no cygwin
    #!/usr/bin/awk
    # Arquivo    : cnpj_cpf.awk
    # Objentivo  : funções para validação de CPF e CNPJ
    # Requisites :
    #     1. SHELL=bash
    #     
    # History    :
    #   #version;date;description
    #   0.1.1b; 23/12/2019; retorna 1 pelo menos um CPF da lista for inválido
    #   0.1.0b; 23/12/2019; first release 
    #
    
    #
    # Tested: cygwin environment
    # 
    
    # verificação de CPF
    function check_cpf(p_cpf) {
      
        # comprimento deve ter onze posições
        if (! ( p_cpf ~ /^[[:digit:]]{11}$/ )) { return FALSE; }
        
        ###
        # regra de validação do CPF
        ###
        
        # quebra o CPF em 2 partes
        cpf9digs=substr(p_cpf,1,9);
        cpf2digs=substr(p_cpf,10,2);
        
        # obtenção do primeiro dígito
        soma=0;
        digv1=0;
        for(p=10;p>=2;p--) {
           dig=substr(cpf9digs,(11-p),1);
           soma+=p*dig;
        }
        mod11soma=soma%11;
        digv1=(mod11soma<2)?0:(11-mod11soma);
            
        # obtenção do segundo dígito
        cpf10digs=cpf9digs digv1;
        soma=0;
        digv2=0;
        for(p=11;p>=2;p--) {
           dig=substr(cpf10digs,(12-p),1);
           soma+=p*dig;
        }
        mod11soma=soma%11;
        digv2=(mod11soma<2)?0:(11-mod11soma);
        
        # dígito verificador completo
        digv=digv1 digv2;
        
        return (( digv == cpf2digs ) ? TRUE : FALSE);
    }
    
    # verificação de CNPJ
    function check_cnpj(p_cnpj) {
           
        # comprimento deve ter onze posições
        if (! ( p_cnpj ~ /^[[:digit:]]{14}$/ )) { return FALSE; }
        
        ###
        # regra de validação do CNPJ
        ###
        
        # quebra o CNPJ em 2 partes
        cnpj12digs=substr(p_cnpj,1,12);
        cnpj2digs=substr(p_cnpj,13,2);
        
        # obtenção do primeiro dígito
        soma=0;
        digv1=0;
        p=2; # peso inicial
        for(i=12;i>=1;i--) {
           dig=substr(cnpj12digs,i,1);
           soma+=p*dig;
           p=(p==9)?2:(p+1);
        }
        mod11soma=soma%11;
        digv1=(mod11soma<2)?0:(11-mod11soma);
      
        # obtenção do segundo dígito
        cnpj13digs=cnpj12digs digv1;
        soma=0;
        digv2=0;
        p=2; # peso inicial
        for(i=13;i>=1;i--) {
           dig=substr(cnpj13digs,i,1);
           soma+=p*dig;
           p=(p==9)?2:(p+1);
        }
        mod11soma=soma%11;
        digv2=(mod11soma<2)?0:(11-mod11soma);
           
        # dígito verificador completo
        digv=digv1 digv2;
        
        return (( digv == cnpj2digs ) ? TRUE : FALSE);
    }
    
    #
    # Variáveis devem ser declaradas neste bloco
    #
    BEGIN {
        # boolean values
        TRUE=1;
        FALSE=0;
        
        # retorna TRUE caso pelo menos um CPF/CNPJ da lista for inválido
        p_retorno=TRUE;
    }
    {
        p_valor=$0;
        p_flag=0;
        
        # se for CPF
        if ( p_valor ~ /^[[:digit:]]{11}$/ ) {
            p_flag=1;
            printf "CPF " p_valor " -  resultado: "; 
            if ( check_cpf(p_valor) == TRUE ) { print "válido";}
            else { 
                p_retorno=FALSE;
                print "inválido";
            }
        }
        
        # se for CNPJ
        if ( p_valor ~ /^[[:digit:]]{14}$/ ) {
            p_flag=1;
            printf "CNPJ " p_valor " -  resultado: "; 
            if ( check_cnpj(p_valor) == TRUE ) { print "válido";}
            else { 
                p_retorno=FALSE;
                print "inválido";
            }
        }
        
        # se não for CPF ou CNPJ
        if ( p_flag == 0 ) {
            p_retorno=FALSE;
            printf p_valor " não é nem CPF nem CNPJ "; 
        }
    }
    END {
        exit p_retorno;
    }						

    public by gwarah  49  1  4  0

    Validação de CPF/CNPJ em PL/SQL

    Pacote em PL/SQL que implementa a validação de CPF e CNPJ. Inclusos no pacote as partes specification e body, além dos comandos de testes
    --
    -- Teste com um destes 3 comandos. saídas:
    -- 1: CPF/CNPJ válido; 2: inválido
    --
    
    -- Para testar um CPF
    -- select pkg_cnpj_cpf.cpf_valido('&cpf') from dual;
    
    -- Para testar um CNPJ
    -- select pkg_cnpj_cpf.cnpj_valido('&cnpj') from dual;
    
    -- Para testar um CPF ou CNPJ
    -- select pkg_cnpj_cpf.cpf_cnpj_valido('&cpf_cnpj') from dual;
    
    --
    -- testado no oracle 12.1
    --
    
    -- /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    -- * Arquivo      : pkg_cnpj_cpf.sql
    -- * Tipo         : pacote pl/sql (specification)
    -- * Objetivo     : validação de CPF/CNPJ
    -- * Observações  :
    -- *   #version;;date;description
    -- *   0.0.2b;17/12/2019; versão beta
    -- *   0.0.1dr;17/12/2019; versão draft
    -- */
    
    CREATE OR REPLACE PACKAGE pkg_cnpj_cpf AS
        subtype tp_validacao is number(1);
    
        /* valores para as situações do CPF válido ou inválido */
        VL_VALIDO   CONSTANT tp_validacao := 1;
        VL_INVALIDO CONSTANT tp_validacao := 2;
    
        /* testa se cpf é válido */
        FUNCTION cpf_valido (
          cpf  VARCHAR2
        ) RETURN tp_validacao;
    
        /* testa se cnpj é válido */
        FUNCTION cnpj_valido (
          cnpj  VARCHAR2
        ) RETURN tp_validacao;
    
        /* testa se cpf/cnpj é válido */
        FUNCTION cpf_cnpj_valido (
          cpf  VARCHAR2
        ) RETURN tp_validacao;
    END pkg_cnpj_cpf;
    /
    
    -- /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    -- * Arquivo      : pkg_cnpj_cpf.sql
    -- * Tipo         : pacote pl/sql (body)
    -- * Objetivo     : validação de CPF/CNPJ
    -- * Observações  :
    -- *   #version;date;description
    -- *   0.0.2b;19/12/2019; versão beta
    -- *   0.0.1dr;17/12/2019; versão draft
    -- */
    CREATE OR REPLACE PACKAGE BODY pkg_cnpj_cpf AS
        
        /* testa se cpf é válido */
        FUNCTION cpf_valido (
          cpf  VARCHAR2
        ) RETURN tp_validacao IS
            resultado tp_validacao := VL_VALIDO;
            num_aux   integer := 0;
            p         number(2) := 0;
            mod11soma number(2) := 0;
            dig       number(1) := 0;
            digv1     integer := 0;
            digv2     integer := 0;
            soma      integer := 0;
            cpf_aux   varchar2(255);
            cpf10digs  varchar2(10);
            cpf9digs  varchar2(9);
            cpf2digs  varchar2(2);
            digv_str  varchar2(2);
        BEGIN
            cpf_aux:=trim(cpf);
    
            -- testes iniciais
            num_aux := 0;
            SELECT count(1) into num_aux FROM DUAL WHERE REGEXP_LIKE(cpf_aux, '^\d{11}$', '');
            if num_aux = 0 then
                RETURN VL_INVALIDO;
            end if;
            
            --
            -- teste do CPF
            --
    
            -- quebra o CPF em 2 partes
            cpf9digs := substr(cpf_aux,1,9);
            cpf2digs := substr(cpf_aux,10,2);
    
            -- obtenção do primeiro dígito
            soma:=0;
            digv1:=0;
    
            FOR p IN REVERSE 2 .. 10 LOOP
                dig := to_number(substr(cpf9digs,(11-p),1));
                soma := soma + (p*dig);
            END LOOP;
    
            mod11soma:=mod(soma,11);
            if mod11soma < 2 then
                digv1:=0;
            else
                digv1:=11-mod11soma;
            end if;
    
            -- obtenção do segundo dígito
            cpf10digs:=cpf9digs || digv1;
            soma:=0;
            digv2:=0;
    
            FOR p IN REVERSE 2 .. 11 LOOP
                dig := to_number(substr(cpf10digs,(12-p),1));
                soma := soma + (p*dig);
            END LOOP;
    
            mod11soma:=mod(soma,11);
            if mod11soma < 2 then
                digv2:=0;
            else
                digv2:=11-mod11soma;
            end if;
    
            -- dígito verficador completo
            digv_str := '' || digv1 || digv2;
    
            -- comparação
            resultado := VL_INVALIDO;
            if digv_str = cpf2digs then 
                resultado := VL_VALIDO;
            end if;
    
            return resultado;
        END cpf_valido;
    
        /* testa se cnpj é válido */
        FUNCTION cnpj_valido (
          cnpj  VARCHAR2
        ) RETURN tp_validacao IS
            resultado   tp_validacao := VL_VALIDO;
            num_aux     integer := 0;
            p           number(2) := 0;
            q           number(2) := 0;
            mod11soma   number(2) := 0;
            dig         number(1) := 0;
            digv1       integer := 0;
            digv2       integer := 0;
            soma        integer := 0;
            cnpj_aux    varchar2(255);
            cnpj13digs  varchar2(13);
            cnpj12digs  varchar2(12);
            cnpj2digs   varchar2(2);
            digv_str    varchar2(2);
        BEGIN
            cnpj_aux:=trim(cnpj);
    
            -- testes iniciais
            num_aux := 0;
            SELECT count(1) into num_aux FROM DUAL WHERE REGEXP_LIKE(cnpj_aux, '^\d{14}$', '');
            
            if num_aux = 0 then
                RETURN VL_INVALIDO;
            end if;
    
            --
            -- teste do CNPJ
            --
    
            -- quebra o CNPJ em 2 partes
            cnpj12digs := substr(cnpj_aux,1,12);
            cnpj2digs := substr(cnpj_aux,13,2);
    
            -- obtenção do primeiro dígito
            soma:=0;
            digv1:=0;
            q:=2; -- peso inicial
            FOR p IN REVERSE 1 .. 12 LOOP
                dig := to_number(substr(cnpj12digs,p,1));
                soma := soma + (q*dig);
                
                if q = 9 then
                    q:=2;
                else
                    q:=q+1;
                end if;
            END LOOP;
            mod11soma := mod(soma,11);
            if mod11soma < 2 then
               digv1 := 0;
            else
               digv1 := 11-mod11soma;
            end if;
    
            -- obtenção do segundo dígito
            cnpj13digs:=cnpj12digs || digv1;
            soma:=0;
            digv2:=0;
            q:=2; -- peso inicial
            
            FOR p IN REVERSE 1 .. 13 LOOP
                dig := to_number(substr(cnpj13digs,p,1));
                soma := soma + (q*dig);
                
                if q = 9 then
                    q:=2;
                else
                    q:=q+1;
                end if;
            END LOOP;
            
            mod11soma := mod(soma,11);
            if mod11soma < 2 then
               digv2 := 0;
            else
               digv2 := 11-mod11soma;
            end if;
            
            -- dígito verficador completo
            digv_str := '' || digv1 || digv2;
    
            -- comparação
            -- dbms_output.put_line('digitos ' || digv_str);
            resultado := VL_INVALIDO;
            if digv_str = cnpj2digs then 
                resultado := VL_VALIDO;
            end if;
            
            return resultado;
        END cnpj_valido;
    
        /* testa se cpf/cnpj é válido */
        FUNCTION cpf_cnpj_valido (
          cpf  VARCHAR2
        ) RETURN tp_validacao IS
            resultado tp_validacao := VL_VALIDO;
        BEGIN
            resultado := cpf_valido(cpf);
            if resultado <> VL_INVALIDO then
                return resultado;
            end if;
            
            resultado := cnpj_valido(cpf);
            
            return resultado;
        END cpf_cnpj_valido;
    END pkg_cnpj_cpf;
    /																																																						

    public by DinhoPutz  92  0  3  0

    Somar valores de um objeto no JavaScript

    Soma os campos de mesmo nome nos itens de um objeto
    var objeto = [
        { valor: 10 }, 
        { valor: 15 }
    ];
    
    objeto;
    
    var somaValores = function (novoObjeto) {
        // Aqui realiza a soma dos valores da propriedade "valor" dentro do objeto
        var total2 = novoObjeto.reduce((total, valor) => total + valor.valor, 0);
        // Resultado da soma 
        console.log( total2 );
    }
    somaValores(objeto);

    public by davizin  205  1  3  0

    /cc/

    /cc/
    
    >eu ainda sinto saudades.
    >eu vi ela de longe andando esses dias no shopping, meu coração ameaçou a acelerar eu sussurrei : calma
    >e eu que sou feito de erros e acertos, assumo que ela foi os dois, mas ainda assim foi minha melhor escolha
    >ela continua linda, desde aquele dia que ela disse: "me beija"
    >nós tínhamos uma mania péssima de achar q a gente ia dar certo, planejamos desde as coisas mais simples como viagens e nome dos nossos filhos
    >até coisas mais complexas como um pra sempre.
    >eu queria ligar pra ela e dizer que o tempo me ajudou a entender meus sentimentos, e que nesse lance entre errar e acertar
    >tem um pouco dos dois em nós
    >eu sinto saudade, não dela, mas de tudo o que poderíamos ter sido.
    >ela nunca soube se ficava ou se ia embora. Eu deveria ter entendido isso
    >é complicado falar sobre saudade, porque com as mesmas linhas que escrevo que ainda amo e ainda quero, também posso usá-las para me enforcar.
    >quando se trata dela, sou inapto a me adaptar à falta que ela me faz
    >tem um pouco dela em mim, sempre.
    >lembro dela sentada com um copo de cerveja na mão me olhando em silêncio, rindo baixinho sem motivo
    >lembro do olhar como quem me agradecia por alguma coisa
    >lembro dela me beijar e dizer
    "amor, me leva embora. quero foder com você"
    >lembro do dia em que terminamos, e ela chorando me disse "me leva embora".
    >e isso também fudeu comigo
    

    public by troy  152  2  5  2

    How can I get an image from raw binary pixel content?

    Given a raw binary content, this gives me a stream that can be easily turned into an Image
    public static async Task<InMemoryRandomAccessStream> ImageFromBytes(this byte[] imagePixels, int width, int dpi, Rect frame)
    {
    	//BitmapImage bitmap = new BitmapImage();
    	int xStart = (int)frame.X;
    	int yStart = (int)frame.Y;
    	int frameWidth = (int)frame.Width;
    	int frameHeight = (int)frame.Height;
    	byte[] framePixels = new byte[4 * frameWidth * frameHeight];
    	for (int y = 0; y < frameHeight; y++)
    	{
    		for (int x = 0; x < frameWidth; x++)
    		{
    			int frameOffset = (4 * y * frameWidth) + (4 * x);
    			int imageOffset = (4 * (y + yStart) * width) + (4 * (x + xStart));
    			framePixels[frameOffset] = imagePixels[imageOffset];
    			framePixels[frameOffset + 1] = imagePixels[imageOffset + 1];
    			framePixels[frameOffset + 2] = imagePixels[imageOffset + 2];
    			framePixels[frameOffset + 3] = imagePixels[imageOffset + 3];
    		}
    	}
    
    	InMemoryRandomAccessStream bitmapStream = new InMemoryRandomAccessStream();
    	BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, bitmapStream);
    	encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, (uint)frameWidth, (uint)frameHeight, dpi, dpi, framePixels);
    
    	try
    	{
    		await encoder.FlushAsync();
    	}
    	catch
    	{
    		return bitmapStream;
    	}
    
    	return bitmapStream;
    }				

    public by troy  435  1  6  1

    What is the size of this file?

    Tells me the size of the given file using the basic properties of UWP StorageFile.
    public static async Task<ulong> GetFileSize(this string filename)
    {
    	StorageFile file = await GetFile(filename);
    	if (file == null)
    		return 0;
    	try
    	{
    		BasicProperties fileSize = await file.GetBasicPropertiesAsync();
    		return fileSize.Size;
    	}
    	catch (Exception e)
    	{
    		s_log.ErrorFormat("Cannot read file {0} due to {1}", filename, e.Message);
    		return 0;
    	}
    }						
    • Public Snippets
    • Channels Snippets