반응형

프로그래밍 언어중에서 조건에따라 작업방식을 달리 할 수 있는 조건문이라는 것이 있습니다. 대표적인 문법이 IF문과 CASE문인데요. MSSQL에서도 조건절인 CASE문과 IF문을 지원하니 한번 활용해보시는 것도 좋을것 같습니다.

 

CASE WHEN

가장 많이쓰이는 조건문입니다. 조건에 따라 값을 지정해 주는 역할을 합니다. 

--CASE사용법--
CASE WHEN 조건절 THEN 참일때 값 ELSE 거짓일때 값 END 컬럼명
--테이블(MY_TABLE)에서 성별(GENDER)이 001이면 여, 그게아니면 남자로 검색--
SELECT DISTINCT
GENDER,
CASE WHEN GENDER = '001' THEN '여' ELSE '남' END AS 성별
FROM MY_TABLE

다중 CASE WHEN

--테이블(MY_TABLE)에서 성적(SCORE)별 학점을 계산
SELECT *,
   (CASE WHEN SCORE>= '90' THEN 'A학점'
        WHEN (SCORE>= '80' AND SCORE < '90') THEN 'B학점'
        WHEN (SCORE>= '70' AND SCORE < '80') THEN 'C학점' 
        WHEN (SCORE>= '60' AND SCORE < '70') THEN 'D학점'
        ELSE 'F학점'
    END) AS '학점'
FROM MY_TABLE

IF ELSE

CASE WHEN과 같은 조건문입니다. CASE문과 마찬가지로 조건에 따라 원하는 작업을 수행할 수 있습니다.

--IF 사용법--
IF 조건 참일때 값 ELSE 거짓일때 값 END 컬럼명
--@NUM 이 30일때 30이라고 출력, 40일경우 40이라고 출력, 아닐경우 아니라고 출력하기--
DECLARE @NUM INT
SET @NUM = 40

IF(@NUM = 30)
PRINT 'NUM은 30입니다.'
ELSE IF(@NUM=40)
PRINT 'NUM은 40입니다'
ELSE
PRINT 'NUM은 30이나 40이 아닙니다.'

출처 : https://coding-factory.tistory.com/113

반응형
반응형

문자열의 일부만 잘라 사용할 경우가 있다.

 

예제를 보면서 바로 해보자

 

var string='2013-06-11';

 

위 문자열을 잘라보겠다.

 

문자열에 있는 '-'를 기준으로 자를려면 다시 만하면 특정 문자를 기준으로 문자열을 자를려면 split을 사용하면 된다.

 

var strArray=string.split('-');

 

이렇게 split함수에 잘라내는데 기준이 될 문자열을 넣으로 문자열을 잘라 배열로 넘겨준다.

 

console.log(strArray[0]+', '+strArray[1]+', '+strArray[2]); 

출력해보면 각 배열에 2013, 06, 11이 담겨진걸 확인 할 수 있다.

 

 

 

다음으로 문자열에서 기준없이 사용하고 싶은 문자열만 골라 가져오고 싶다면

 

substring함수를 사용하면 된다.

 

substring함수는 문자열의 길이를 기준으로 자른다고 표현하기보다 일정 문자열을 반환한다.

 

substring(시작인덱스, 종료인덱스);

var year=string.substring(0,4) //2013

var month=string.substring(5,7) //06

var day=string.substring(8,10) //11

 

출력해 보면 원하는 값이 잘 출력될 것이다.

 

 

위와 비슷하지만 조금 다른 함수 substr이 있다.

 

 

 

substr(시작인덱스, 길이)

var year=string.substr(0,4) //2013

var month=string.substr(5,2) //06

var day=string.substr(8,2) //11

 

출력해보면 substring과 출력 결과가 같다



출처: https://squll1.tistory.com/entry/javascript-문자열-자르기-split-substring-substr [아는만큼 보여요]

반응형
반응형

There are quite a bit of answers to handle it client side, but you can change the output server side if you desired.

There are a few ways to approach this, I'll start with the basics. You'll have to subclass the JsonResult class and override the ExecuteResult method. From there you can take a few different approaches to change the serialization.

Approach 1: The default implementation uses the . If you take a look at the documentation, you can use the RegisterConverters method to add custom . There are a few problems with this though: The JavaScriptConverter serializes to a dictionary, that is it takes an object and serializes to a Json dictionary. In order to make the object serialize to a string it requires a bit of hackery, see . This particular hack will also escape the string.

 

번역:

클라이언트측에서 처리할 수 있는 답변이 꽤 많지만, 원한다면 출력 서버측을 변경할 수 있다.
여기에 접근하는 방법에는 몇 가지가 있는데, 기본부터 짚어보겠다. JsonResult 클래스를 하위 클래스로 분류하고 ExecuteResult 메소드를 재정의하십시오. 거기서 당신은 연재물을 바꾸기 위해 몇 가지 다른 접근법을 취할 수 있다.
접근 1:
기본 구현은 을 사용한다. 설명서를 보면 RegisterConverters 방법을 사용하여 사용자 정의 를 추가할 수 있다. 그러나 다음과 같은 몇 가지 문제가 있다. JavaScriptConverter는 사전을 연재한다. 즉, 사물을 가져다가 Json 사전을 연재한다. 객체를 문자열로 직렬화하려면 약간의 진부함이 필요하다( 참조 이 특별한 해킹은 또한 끈에서 벗어날 것이다.

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            // Use your custom JavaScriptConverter subclass here.
            serializer.RegisterConverters(new JavascriptConverter[] { new CustomConverter });

            response.Write(serializer.Serialize(Data));
        }
    }
}

Approach 2 (recommended): The second approach is to start with the overridden JsonResult and go with another Json serializer, in my case the serializer. This doesn't require the hackery of approach 1. Here is my implementation of the JsonResult subclass:

 

번역: 

접근 2(권장): 두 번째 방법은 오버라이드된 JsonResult부터 시작해서 다른 Json serializer, 내 경우 serializer로 가는 것이다. 이것은 접근 1의 속임수를 필요로 하지 않는다. JsonResult 하위 클래스에 대한 구현:

 

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            // Using Json.NET serializer
            var isoConvert = new IsoDateTimeConverter();
            isoConvert.DateTimeFormat = _dateFormat;
            response.Write(JsonConvert.SerializeObject(Data, isoConvert));
        }
    }
}

Usage Example:

[HttpGet]
public ActionResult Index() {
    return new CustomJsonResult { Data = new { users=db.Users.ToList(); } };
}

 

매우매우 유용한 답변이다. Json은 date타입을 파싱하지 못하는데 클라이언트측에서해결하는 방식이 아닌 서버단에서 해결하는 방식으로 매우매우 유용하다. 

 

출처 : https://stackoverflow.com/questions/726334/asp-net-mvc-jsonresult-date-format

반응형
반응형

텍스트를 요청 파라미터로 넣으면

암호화된 값을 리턴합니다.

Sha256Encryption: function (ascii) {
            /**
             * sha256 암호화 
             * 암호화된 text를 출력한다.
             */
            function rightRotate(value, amount) {
                return (value>>>amount) | (value<<(32 - amount));
            };

            var mathPow = Math.pow;
            var maxWord = mathPow(2, 32);
            var lengthProperty = 'length'
            var i, j; // Used as a counter across the whole file
            var result = ''

            var words = [];
            var asciiBitLength = ascii[lengthProperty]*8;

            //* caching results is optional - remove/add slash from front of this line to toggle
            // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
            // (we actually calculate the first 64, but extra values are just ignored)
            var hash = this.Sha256Encryption.h = this.Sha256Encryption.h || [];
            // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
            var k = this.Sha256Encryption.k = this.Sha256Encryption.k || [];
            var primeCounter = k[lengthProperty];
            /*/
            var hash = [], k = [];
            var primeCounter = 0;
            //*/

            var isComposite = {};
            for (var candidate = 2; primeCounter < 64; candidate++) {
                if (!isComposite[candidate]) {
                    for (i = 0; i < 313; i += candidate) {
                        isComposite[i] = candidate;
                    }
                    hash[primeCounter] = (mathPow(candidate, .5)*maxWord)|0;
                    k[primeCounter++] = (mathPow(candidate, 1/3)*maxWord)|0;
                }
            }

            ascii += '\x80' // Append Ƈ' bit (plus zero padding)
            while (ascii[lengthProperty]%64 - 56) ascii += '\x00' // More zero padding
            for (i = 0; i < ascii[lengthProperty]; i++) {
                j = ascii.charCodeAt(i);
                if (j>>8) return; // ASCII check: only accept characters in range 0-255
                words[i>>2] |= j << ((3 - i)%4)*8;
            }
            words[words[lengthProperty]] = ((asciiBitLength/maxWord)|0);
            words[words[lengthProperty]] = (asciiBitLength)

            // process each chunk
            for (j = 0; j < words[lengthProperty];) {
                var w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
                var oldHash = hash;
                // This is now the undefinedworking hash", often labelled as variables a...g
                // (we have to truncate as well, otherwise extra entries at the end accumulate
                hash = hash.slice(0, 8);

                for (i = 0; i < 64; i++) {
                    var i2 = i + j;
                    // Expand the message into 64 words
                    // Used below if 
                    var w15 = w[i - 15], w2 = w[i - 2];

                    // Iterate
                    var a = hash[0], e = hash[4];
                    var temp1 = hash[7]
                        + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
                        + ((e&hash[5])^((~e)&hash[6])) // ch
                        + k[i]
                        // Expand the message schedule if needed
                        + (w[i] = (i < 16) ? w[i] : (
                                w[i - 16]
                                + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15>>>3)) // s0
                                + w[i - 7]
                                + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2>>>10)) // s1
                            )|0
                        );
                    // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
                    var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
                        + ((a&hash[1])^(a&hash[2])^(hash[1]&hash[2])); // maj

                    hash = [(temp1 + temp2)|0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()
                    hash[4] = (hash[4] + temp1)|0;
                }

                for (i = 0; i < 8; i++) {
                    hash[i] = (hash[i] + oldHash[i])|0;
                }
            }

            for (i = 0; i < 8; i++) {
                for (j = 3; j + 1; j--) {
                    var b = (hash[i]>>(j*8))&255;
                    result += ((b < 16) ? 0 : '') + b.toString(16);
                }
            }
            return result;
        }

 

암호화된 값은 : https://md5decrypt.net/en/Sha256/

 

Sha256 Decrypt & Encrypt - More than 15.000.000.000 hashes

 

md5decrypt.net

 

여기서 확인 가능합니다.

반응형

+ Recent posts